@pdfme/pdf-lib 0.0.0

package/src/core/structures/PDFCrossRefStream.ts

@@ -0,0 +1,238 @@
+import PDFDict from '../objects/PDFDict';
+import PDFName from '../objects/PDFName';
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+import PDFFlateStream from './PDFFlateStream';
+import { bytesFor, Cache, reverseArray, sizeInBytes, sum } from '../../utils';
+
+export enum EntryType {
+  Deleted = 0,
+  Uncompressed = 1,
+  Compressed = 2,
+}
+
+export interface DeletedEntry {
+  type: EntryType.Deleted;
+  ref: PDFRef;
+  nextFreeObjectNumber: number;
+}
+
+export interface UncompressedEntry {
+  type: EntryType.Uncompressed;
+  ref: PDFRef;
+  offset: number;
+}
+
+export interface CompressedEntry {
+  type: EntryType.Compressed;
+  ref: PDFRef;
+  objectStreamRef: PDFRef;
+  index: number;
+}
+
+export type Entry = DeletedEntry | UncompressedEntry | CompressedEntry;
+
+export type EntryTuple = [number, number, number];
+
+/**
+ * Entries should be added using the [[addDeletedEntry]],
+ * [[addUncompressedEntry]], and [[addCompressedEntry]] methods
+ * **in order of ascending object number**.
+ */
+class PDFCrossRefStream extends PDFFlateStream {
+  static create = (dict: PDFDict, encode = true) => {
+    const stream = new PDFCrossRefStream(dict, [], encode);
+    stream.addDeletedEntry(PDFRef.of(0, 65535), 0);
+    return stream;
+  };
+
+  static of = (dict: PDFDict, entries: Entry[], encode = true) =>
+    new PDFCrossRefStream(dict, entries, encode);
+
+  private readonly entries: Entry[];
+  private readonly entryTuplesCache: Cache<EntryTuple[]>;
+  private readonly maxByteWidthsCache: Cache<[number, number, number]>;
+  private readonly indexCache: Cache<number[]>;
+
+  private constructor(dict: PDFDict, entries?: Entry[], encode = true) {
+    super(dict, encode);
+
+    this.entries = entries || [];
+    this.entryTuplesCache = Cache.populatedBy(this.computeEntryTuples);
+    this.maxByteWidthsCache = Cache.populatedBy(this.computeMaxEntryByteWidths);
+    this.indexCache = Cache.populatedBy(this.computeIndex);
+
+    dict.set(PDFName.of('Type'), PDFName.of('XRef'));
+  }
+
+  addDeletedEntry(ref: PDFRef, nextFreeObjectNumber: number) {
+    const type = EntryType.Deleted;
+    this.entries.push({ type, ref, nextFreeObjectNumber });
+    this.entryTuplesCache.invalidate();
+    this.maxByteWidthsCache.invalidate();
+    this.indexCache.invalidate();
+    this.contentsCache.invalidate();
+  }
+
+  addUncompressedEntry(ref: PDFRef, offset: number) {
+    const type = EntryType.Uncompressed;
+    this.entries.push({ type, ref, offset });
+    this.entryTuplesCache.invalidate();
+    this.maxByteWidthsCache.invalidate();
+    this.indexCache.invalidate();
+    this.contentsCache.invalidate();
+  }
+
+  addCompressedEntry(ref: PDFRef, objectStreamRef: PDFRef, index: number) {
+    const type = EntryType.Compressed;
+    this.entries.push({ type, ref, objectStreamRef, index });
+    this.entryTuplesCache.invalidate();
+    this.maxByteWidthsCache.invalidate();
+    this.indexCache.invalidate();
+    this.contentsCache.invalidate();
+  }
+
+  clone(context?: PDFContext): PDFCrossRefStream {
+    const { dict, entries, encode } = this;
+    return PDFCrossRefStream.of(dict.clone(context), entries.slice(), encode);
+  }
+
+  getContentsString(): string {
+    const entryTuples = this.entryTuplesCache.access();
+    const byteWidths = this.maxByteWidthsCache.access();
+    let value = '';
+
+    for (let entryIdx = 0, entriesLen = entryTuples.length; entryIdx < entriesLen; entryIdx++) {
+      const [first, second, third] = entryTuples[entryIdx];
+
+      const firstBytes = reverseArray(bytesFor(first));
+      const secondBytes = reverseArray(bytesFor(second));
+      const thirdBytes = reverseArray(bytesFor(third));
+
+      for (let idx = byteWidths[0] - 1; idx >= 0; idx--) {
+        value += (firstBytes[idx] || 0).toString(2);
+      }
+      for (let idx = byteWidths[1] - 1; idx >= 0; idx--) {
+        value += (secondBytes[idx] || 0).toString(2);
+      }
+      for (let idx = byteWidths[2] - 1; idx >= 0; idx--) {
+        value += (thirdBytes[idx] || 0).toString(2);
+      }
+    }
+
+    return value;
+  }
+
+  getUnencodedContents(): Uint8Array {
+    const entryTuples = this.entryTuplesCache.access();
+    const byteWidths = this.maxByteWidthsCache.access();
+    const buffer = new Uint8Array(this.getUnencodedContentsSize());
+
+    let offset = 0;
+    for (let entryIdx = 0, entriesLen = entryTuples.length; entryIdx < entriesLen; entryIdx++) {
+      const [first, second, third] = entryTuples[entryIdx];
+
+      const firstBytes = reverseArray(bytesFor(first));
+      const secondBytes = reverseArray(bytesFor(second));
+      const thirdBytes = reverseArray(bytesFor(third));
+
+      for (let idx = byteWidths[0] - 1; idx >= 0; idx--) {
+        buffer[offset++] = firstBytes[idx] || 0;
+      }
+      for (let idx = byteWidths[1] - 1; idx >= 0; idx--) {
+        buffer[offset++] = secondBytes[idx] || 0;
+      }
+      for (let idx = byteWidths[2] - 1; idx >= 0; idx--) {
+        buffer[offset++] = thirdBytes[idx] || 0;
+      }
+    }
+
+    return buffer;
+  }
+
+  getUnencodedContentsSize(): number {
+    const byteWidths = this.maxByteWidthsCache.access();
+    const entryWidth = sum(byteWidths);
+    return entryWidth * this.entries.length;
+  }
+
+  updateDict(): void {
+    super.updateDict();
+
+    const byteWidths = this.maxByteWidthsCache.access();
+    const index = this.indexCache.access();
+
+    const { context } = this.dict;
+    this.dict.set(PDFName.of('W'), context.obj(byteWidths));
+    this.dict.set(PDFName.of('Index'), context.obj(index));
+  }
+
+  // Returns an array of integer pairs for each subsection of the cross ref
+  // section, where each integer pair represents:
+  //   firstObjectNumber(OfSection), length(OfSection)
+  private computeIndex = (): number[] => {
+    const subsections: number[] = [];
+
+    let subsectionLength = 0;
+    for (let idx = 0, len = this.entries.length; idx < len; idx++) {
+      const currEntry = this.entries[idx];
+      const prevEntry = this.entries[idx - 1];
+
+      if (idx === 0) {
+        subsections.push(currEntry.ref.objectNumber);
+      } else if (currEntry.ref.objectNumber - prevEntry.ref.objectNumber > 1) {
+        subsections.push(subsectionLength);
+        subsections.push(currEntry.ref.objectNumber);
+        subsectionLength = 0;
+      }
+
+      subsectionLength += 1;
+    }
+    subsections.push(subsectionLength);
+
+    return subsections;
+  };
+
+  private computeEntryTuples = (): EntryTuple[] => {
+    const entryTuples: EntryTuple[] = new Array(this.entries.length);
+
+    for (let idx = 0, len = this.entries.length; idx < len; idx++) {
+      const entry = this.entries[idx];
+      if (entry.type === EntryType.Deleted) {
+        const { type, nextFreeObjectNumber, ref } = entry;
+        entryTuples[idx] = [type, nextFreeObjectNumber, ref.generationNumber];
+      }
+      if (entry.type === EntryType.Uncompressed) {
+        const { type, offset, ref } = entry;
+        entryTuples[idx] = [type, offset, ref.generationNumber];
+      }
+      if (entry.type === EntryType.Compressed) {
+        const { type, objectStreamRef, index } = entry;
+        entryTuples[idx] = [type, objectStreamRef.objectNumber, index];
+      }
+    }
+
+    return entryTuples;
+  };
+
+  private computeMaxEntryByteWidths = (): [number, number, number] => {
+    const entryTuples = this.entryTuplesCache.access();
+    const widths: [number, number, number] = [0, 0, 0];
+
+    for (let idx = 0, len = entryTuples.length; idx < len; idx++) {
+      const [first, second, third] = entryTuples[idx];
+
+      const firstSize = sizeInBytes(first);
+      const secondSize = sizeInBytes(second);
+      const thirdSize = sizeInBytes(third);
+
+      if (firstSize > widths[0]) widths[0] = firstSize;
+      if (secondSize > widths[1]) widths[1] = secondSize;
+      if (thirdSize > widths[2]) widths[2] = thirdSize;
+    }
+
+    return widths;
+  };
+}
+
+export default PDFCrossRefStream;

package/src/core/structures/PDFFlateStream.ts

@@ -0,0 +1,40 @@
+import pako from 'pako';
+
+import { MethodNotImplementedError } from '../errors';
+import PDFDict from '../objects/PDFDict';
+import PDFName from '../objects/PDFName';
+import PDFStream from '../objects/PDFStream';
+import { Cache } from '../../utils';
+
+class PDFFlateStream extends PDFStream {
+  protected readonly contentsCache: Cache<Uint8Array>;
+  protected readonly encode: boolean;
+
+  constructor(dict: PDFDict, encode: boolean) {
+    super(dict);
+
+    this.encode = encode;
+
+    if (encode) dict.set(PDFName.of('Filter'), PDFName.of('FlateDecode'));
+    this.contentsCache = Cache.populatedBy(this.computeContents);
+  }
+
+  computeContents = (): Uint8Array => {
+    const unencodedContents = this.getUnencodedContents();
+    return this.encode ? pako.deflate(unencodedContents) : unencodedContents;
+  };
+
+  getContents(): Uint8Array {
+    return this.contentsCache.access();
+  }
+
+  getContentsSize(): number {
+    return this.contentsCache.access().length;
+  }
+
+  getUnencodedContents(): Uint8Array {
+    throw new MethodNotImplementedError(this.constructor.name, 'getUnencodedContents');
+  }
+}
+
+export default PDFFlateStream;

package/src/core/structures/PDFObjectStream.ts

@@ -0,0 +1,91 @@
+import PDFName from '../objects/PDFName';
+import PDFNumber from '../objects/PDFNumber';
+import PDFObject from '../objects/PDFObject';
+import PDFRef from '../objects/PDFRef';
+import PDFContext from '../PDFContext';
+import PDFFlateStream from './PDFFlateStream';
+import CharCodes from '../syntax/CharCodes';
+import { copyStringIntoBuffer, last } from '../../utils';
+
+export type IndirectObject = [PDFRef, PDFObject];
+
+class PDFObjectStream extends PDFFlateStream {
+  static withContextAndObjects = (context: PDFContext, objects: IndirectObject[], encode = true) =>
+    new PDFObjectStream(context, objects, encode);
+
+  private readonly objects: IndirectObject[];
+  private readonly offsets: [number, number][];
+  private readonly offsetsString: string;
+
+  private constructor(context: PDFContext, objects: IndirectObject[], encode = true) {
+    super(context.obj({}), encode);
+
+    this.objects = objects;
+    this.offsets = this.computeObjectOffsets();
+    this.offsetsString = this.computeOffsetsString();
+
+    this.dict.set(PDFName.of('Type'), PDFName.of('ObjStm'));
+    this.dict.set(PDFName.of('N'), PDFNumber.of(this.objects.length));
+    this.dict.set(PDFName.of('First'), PDFNumber.of(this.offsetsString.length));
+  }
+
+  getObjectsCount(): number {
+    return this.objects.length;
+  }
+
+  clone(context?: PDFContext): PDFObjectStream {
+    return PDFObjectStream.withContextAndObjects(
+      context || this.dict.context,
+      this.objects.slice(),
+      this.encode,
+    );
+  }
+
+  getContentsString(): string {
+    let value = this.offsetsString;
+    for (let idx = 0, len = this.objects.length; idx < len; idx++) {
+      const [, object] = this.objects[idx];
+      value += `${object}\n`;
+    }
+    return value;
+  }
+
+  getUnencodedContents(): Uint8Array {
+    const buffer = new Uint8Array(this.getUnencodedContentsSize());
+    let offset = copyStringIntoBuffer(this.offsetsString, buffer, 0);
+    for (let idx = 0, len = this.objects.length; idx < len; idx++) {
+      const [, object] = this.objects[idx];
+      offset += object.copyBytesInto(buffer, offset);
+      buffer[offset++] = CharCodes.Newline;
+    }
+    return buffer;
+  }
+
+  getUnencodedContentsSize(): number {
+    return (
+      this.offsetsString.length + last(this.offsets)[1] + last(this.objects)[1].sizeInBytes() + 1
+    );
+  }
+
+  private computeOffsetsString(): string {
+    let offsetsString = '';
+    for (let idx = 0, len = this.offsets.length; idx < len; idx++) {
+      const [objectNumber, offset] = this.offsets[idx];
+      offsetsString += `${objectNumber} ${offset} `;
+    }
+    return offsetsString;
+  }
+
+  private computeObjectOffsets(): [number, number][] {
+    let offset = 0;
+    const offsets = new Array(this.objects.length);
+    for (let idx = 0, len = this.objects.length; idx < len; idx++) {
+      const [ref, object] = this.objects[idx];
+      offsets[idx] = [ref.objectNumber, offset];
+      offset += object.sizeInBytes() + 1; // '\n'
+    }
+    return offsets;
+  }
+}
+
+export default PDFObjectStream;

package/src/core/structures/PDFPageLeaf.ts

@@ -0,0 +1,244 @@
+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';
+
+class PDFPageLeaf extends PDFDict {
+  static readonly InheritableEntries = ['Resources', 'MediaBox', 'CropBox', 'Rotate'];
+
+  static withContextAndParent = (context: PDFContext, parent: PDFRef) => {
+    const dict = new Map();
+    dict.set(PDFName.Type, PDFName.Page);
+    dict.set(PDFName.Parent, parent);
+    dict.set(PDFName.Resources, context.obj({}));
+    dict.set(PDFName.MediaBox, context.obj([0, 0, 612, 792]));
+    return new PDFPageLeaf(dict, context, false);
+  };
+
+  static fromMapWithContext = (map: DictMap, context: PDFContext, autoNormalizeCTM = true) =>
+    new PDFPageLeaf(map, context, autoNormalizeCTM);
+
+  private normalized = false;
+  private readonly autoNormalizeCTM: boolean;
+
+  private constructor(map: DictMap, context: PDFContext, autoNormalizeCTM = true) {
+    super(map, context);
+    this.autoNormalizeCTM = autoNormalizeCTM;
+  }
+
+  clone(context?: PDFContext): PDFPageLeaf {
+    const clone = PDFPageLeaf.fromMapWithContext(
+      new Map(),
+      context || this.context,
+      this.autoNormalizeCTM,
+    );
+    const entries = this.entries();
+    for (let idx = 0, len = entries.length; idx < len; idx++) {
+      const [key, value] = entries[idx];
+      clone.set(key, value);
+    }
+    return clone;
+  }
+
+  Parent(): PDFPageTree | undefined {
+    return this.lookupMaybe(PDFName.Parent, PDFDict) as PDFPageTree | undefined;
+  }
+
+  Contents(): PDFStream | PDFArray | undefined {
+    return this.lookup(PDFName.of('Contents')) as PDFStream | PDFArray | undefined;
+  }
+
+  Annots(): PDFArray | undefined {
+    return this.lookupMaybe(PDFName.Annots, PDFArray);
+  }
+
+  BleedBox(): PDFArray | undefined {
+    return this.lookupMaybe(PDFName.BleedBox, PDFArray);
+  }
+
+  TrimBox(): PDFArray | undefined {
+    return this.lookupMaybe(PDFName.TrimBox, PDFArray);
+  }
+
+  ArtBox(): PDFArray | undefined {
+    return this.lookupMaybe(PDFName.ArtBox, PDFArray);
+  }
+
+  Resources(): PDFDict | undefined {
+    const dictOrRef = this.getInheritableAttribute(PDFName.Resources);
+    return this.context.lookupMaybe(dictOrRef, PDFDict);
+  }
+
+  MediaBox(): PDFArray {
+    const arrayOrRef = this.getInheritableAttribute(PDFName.MediaBox);
+    return this.context.lookup(arrayOrRef, PDFArray);
+  }
+
+  CropBox(): PDFArray | undefined {
+    const arrayOrRef = this.getInheritableAttribute(PDFName.CropBox);
+    return this.context.lookupMaybe(arrayOrRef, PDFArray);
+  }
+
+  Rotate(): PDFNumber | undefined {
+    const numberOrRef = this.getInheritableAttribute(PDFName.Rotate);
+    return this.context.lookupMaybe(numberOrRef, PDFNumber);
+  }
+
+  getInheritableAttribute(name: PDFName): PDFObject | undefined {
+    let attribute: PDFObject | undefined;
+    this.ascend((node) => {
+      if (!attribute) attribute = node.get(name);
+    });
+    return attribute;
+  }
+
+  setParent(parentRef: PDFRef): void {
+    this.set(PDFName.Parent, parentRef);
+  }
+
+  addContentStream(contentStreamRef: PDFRef): void {
+    const Contents = this.normalizedEntries().Contents || this.context.obj([]);
+    this.set(PDFName.Contents, Contents);
+    Contents.push(contentStreamRef);
+  }
+
+  wrapContentStreams(startStream: PDFRef, endStream: PDFRef): boolean {
+    const Contents = this.Contents();
+    if (Contents instanceof PDFArray) {
+      Contents.insert(0, startStream);
+      Contents.push(endStream);
+      return true;
+    }
+    return false;
+  }
+
+  addAnnot(annotRef: PDFRef): void {
+    const { Annots } = this.normalizedEntries();
+    Annots.push(annotRef);
+  }
+
+  removeAnnot(annotRef: PDFRef) {
+    const { Annots } = this.normalizedEntries();
+    const index = Annots.indexOf(annotRef);
+    if (index !== undefined) {
+      Annots.remove(index);
+    }
+  }
+
+  setFontDictionary(name: PDFName, fontDictRef: PDFRef): void {
+    const { Font } = this.normalizedEntries();
+    Font.set(name, fontDictRef);
+  }
+
+  newFontDictionaryKey(tag: string): PDFName {
+    const { Font } = this.normalizedEntries();
+    return Font.uniqueKey(tag);
+  }
+
+  newFontDictionary(tag: string, fontDictRef: PDFRef): PDFName {
+    const key = this.newFontDictionaryKey(tag);
+    this.setFontDictionary(key, fontDictRef);
+    return key;
+  }
+
+  setXObject(name: PDFName, xObjectRef: PDFRef): void {
+    const { XObject } = this.normalizedEntries();
+    XObject.set(name, xObjectRef);
+  }
+
+  newXObjectKey(tag: string): PDFName {
+    const { XObject } = this.normalizedEntries();
+    return XObject.uniqueKey(tag);
+  }
+
+  newXObject(tag: string, xObjectRef: PDFRef): PDFName {
+    const key = this.newXObjectKey(tag);
+    this.setXObject(key, xObjectRef);
+    return key;
+  }
+
+  setExtGState(name: PDFName, extGStateRef: PDFRef | PDFDict): void {
+    const { ExtGState } = this.normalizedEntries();
+    ExtGState.set(name, extGStateRef);
+  }
+
+  newExtGStateKey(tag: string): PDFName {
+    const { ExtGState } = this.normalizedEntries();
+    return ExtGState.uniqueKey(tag);
+  }
+
+  newExtGState(tag: string, extGStateRef: PDFRef | PDFDict): PDFName {
+    const key = this.newExtGStateKey(tag);
+    this.setExtGState(key, extGStateRef);
+    return key;
+  }
+
+  ascend(visitor: (node: PDFPageTree | PDFPageLeaf) => any): void {
+    visitor(this);
+    const Parent = this.Parent();
+    if (Parent) Parent.ascend(visitor);
+  }
+
+  normalize() {
+    if (this.normalized) return;
+
+    const { context } = this;
+
+    const contentsRef = this.get(PDFName.Contents);
+    const contents = this.context.lookup(contentsRef);
+    if (contents instanceof PDFStream) {
+      this.set(PDFName.Contents, context.obj([contentsRef]));
+    }
+
+    if (this.autoNormalizeCTM) {
+      this.wrapContentStreams(
+        this.context.getPushGraphicsStateContentStream(),
+        this.context.getPopGraphicsStateContentStream(),
+      );
+    }
+
+    // TODO: Clone `Resources` if it is inherited
+    const dictOrRef = this.getInheritableAttribute(PDFName.Resources);
+    const Resources = context.lookupMaybe(dictOrRef, PDFDict) || context.obj({});
+    this.set(PDFName.Resources, Resources);
+
+    // TODO: Clone `Font` if it is inherited
+    const Font = Resources.lookupMaybe(PDFName.Font, PDFDict) || context.obj({});
+    Resources.set(PDFName.Font, Font);
+
+    // TODO: Clone `XObject` if it is inherited
+    const XObject = Resources.lookupMaybe(PDFName.XObject, PDFDict) || context.obj({});
+    Resources.set(PDFName.XObject, XObject);
+
+    // TODO: Clone `ExtGState` if it is inherited
+    const ExtGState = Resources.lookupMaybe(PDFName.ExtGState, PDFDict) || context.obj({});
+    Resources.set(PDFName.ExtGState, ExtGState);
+
+    const Annots = this.Annots() || context.obj([]);
+    this.set(PDFName.Annots, Annots);
+
+    this.normalized = true;
+  }
+
+  normalizedEntries() {
+    this.normalize();
+    const Annots = this.Annots()!;
+    const Resources = this.Resources()!;
+    const Contents = this.Contents() as PDFArray | undefined;
+    return {
+      Annots,
+      Resources,
+      Contents,
+      Font: Resources.lookup(PDFName.Font, PDFDict),
+      XObject: Resources.lookup(PDFName.XObject, PDFDict),
+      ExtGState: Resources.lookup(PDFName.ExtGState, PDFDict),
+    };
+  }
+}
+
+export default PDFPageLeaf;