@adnsistemas/pdf-lib 1.18.0

package/src/core/structures/PDFPageTree.ts

@@ -0,0 +1,195 @@
+import PDFArray from 'src/core/objects/PDFArray';
+import PDFDict, { DictMap } from 'src/core/objects/PDFDict';
+import PDFName from 'src/core/objects/PDFName';
+import PDFNumber from 'src/core/objects/PDFNumber';
+import PDFRef from 'src/core/objects/PDFRef';
+import PDFContext from 'src/core/PDFContext';
+import PDFPageLeaf from 'src/core/structures/PDFPageLeaf';
+import { InvalidTargetIndexError, CorruptPageTreeError } from 'src/core/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

@@ -0,0 +1,62 @@
+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 = 45,
+  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

@@ -0,0 +1,14 @@
+import CharCodes from 'src/core/syntax/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

@@ -0,0 +1,10 @@
+import CharCodes from 'src/core/syntax/CharCodes';
+import { IsDelimiter } from 'src/core/syntax/Delimiters';
+import { IsWhitespace } from 'src/core/syntax/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

@@ -0,0 +1,83 @@
+import CharCodes from 'src/core/syntax/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

@@ -0,0 +1,26 @@
+import CharCodes from 'src/core/syntax/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

@@ -0,0 +1,10 @@
+import CharCodes from 'src/core/syntax/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

@@ -0,0 +1,158 @@
+import { defaultDocumentSnapshot, DocumentSnapshot } from 'src/api/snapshot';
+import PDFHeader from 'src/core/document/PDFHeader';
+import PDFTrailer from 'src/core/document/PDFTrailer';
+import PDFInvalidObject from 'src/core/objects/PDFInvalidObject';
+import PDFName from 'src/core/objects/PDFName';
+import PDFNumber from 'src/core/objects/PDFNumber';
+import PDFObject from 'src/core/objects/PDFObject';
+import PDFRef from 'src/core/objects/PDFRef';
+import PDFStream from 'src/core/objects/PDFStream';
+import PDFContext from 'src/core/PDFContext';
+import PDFCrossRefStream from 'src/core/structures/PDFCrossRefStream';
+import PDFObjectStream from 'src/core/structures/PDFObjectStream';
+import PDFWriter from 'src/core/writers/PDFWriter';
+import { last, waitForTick } from 'src/utils';
+import PDFDict from '../objects/PDFDict';
+
+class PDFStreamWriter extends PDFWriter {
+  static forContext = (
+    context: PDFContext,
+    objectsPerTick: number,
+    encodeStreams = true,
+    objectsPerStream = 50,
+  ) =>
+    new PDFStreamWriter(
+      context,
+      objectsPerTick,
+      defaultDocumentSnapshot,
+      encodeStreams,
+      objectsPerStream,
+    );
+
+  static forContextWithSnapshot = (
+    context: PDFContext,
+    objectsPerTick: number,
+    snapshot: DocumentSnapshot,
+    encodeStreams = true,
+    objectsPerStream = 50,
+  ) =>
+    new PDFStreamWriter(
+      context,
+      objectsPerTick,
+      snapshot,
+      encodeStreams,
+      objectsPerStream,
+    );
+
+  private readonly encodeStreams: boolean;
+  private readonly objectsPerStream: number;
+
+  private constructor(
+    context: PDFContext,
+    objectsPerTick: number,
+    snapshot: DocumentSnapshot,
+    encodeStreams: boolean,
+    objectsPerStream: number,
+  ) {
+    super(context, objectsPerTick, snapshot);
+
+    this.encodeStreams = encodeStreams;
+    this.objectsPerStream = objectsPerStream;
+  }
+
+  protected async computeBufferSize(incremental: boolean) {
+    let objectNumber = this.context.largestObjectNumber + 1;
+
+    const header = PDFHeader.forVersion(1, 7);
+
+    let size = this.snapshot.pdfSize;
+    if (!incremental) {
+      size += header.sizeInBytes() + 1;
+    }
+    size += 1;
+
+    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;
+      if (!this.snapshot.shouldSave(ref.objectNumber)) {
+        continue;
+      }
+
+      const shouldNotCompress =
+        ref === this.context.trailerInfo.Encrypt ||
+        object instanceof PDFStream ||
+        object instanceof PDFInvalidObject ||
+        ref.generationNumber !== 0 ||
+        (object instanceof PDFDict &&
+          (object as PDFDict).lookup(PDFName.of('Type')) === PDFName.of('Sig'));
+
+      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));
+    if (this.snapshot.prevStartXRef) {
+      xrefStream.dict.set(
+        PDFName.of('Prev'),
+        PDFNumber.of(this.snapshot.prevStartXRef),
+      );
+    }
+    xrefStream.addUncompressedEntry(xrefStreamRef, size);
+    const xrefOffset = size;
+    size += this.computeIndirectObjectSize([xrefStreamRef, xrefStream]);
+
+    uncompressedObjects.push([xrefStreamRef, xrefStream]);
+
+    const trailer = PDFTrailer.forLastCrossRefSectionOffset(xrefOffset);
+    size += trailer.sizeInBytes();
+    size -= this.snapshot.pdfSize;
+
+    return { size, header, indirectObjects: uncompressedObjects, trailer };
+  }
+}
+
+export default PDFStreamWriter;