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

package/src/core/structures/PDFCrossRefStream.ts

@@ -1,238 +0,0 @@
-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[] = 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

@@ -1,40 +0,0 @@
-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

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

@@ -1,244 +0,0 @@
-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;