@pdfme/pdf-lib 0.0.0

package/src/core/objects/PDFArray.ts

@@ -0,0 +1,179 @@
+import PDFBool from './PDFBool';
+import PDFDict from './PDFDict';
+import PDFHexString from './PDFHexString';
+import PDFName from './PDFName';
+import PDFNull from './PDFNull';
+import PDFNumber from './PDFNumber';
+import PDFObject from './PDFObject';
+import PDFRef from './PDFRef';
+import PDFStream from './PDFStream';
+import PDFString from './PDFString';
+import PDFContext from '../PDFContext';
+import CharCodes from '../syntax/CharCodes';
+import { PDFArrayIsNotRectangleError } from '../errors';
+import PDFRawStream from './PDFRawStream';
+
+class PDFArray extends PDFObject {
+  static withContext = (context: PDFContext) => new PDFArray(context);
+
+  private readonly array: PDFObject[];
+  private readonly context: PDFContext;
+
+  private constructor(context: PDFContext) {
+    super();
+    this.array = [];
+    this.context = context;
+  }
+
+  size(): number {
+    return this.array.length;
+  }
+
+  push(object: PDFObject): void {
+    this.array.push(object);
+  }
+
+  insert(index: number, object: PDFObject): void {
+    this.array.splice(index, 0, object);
+  }
+
+  indexOf(object: PDFObject): number | undefined {
+    const index = this.array.indexOf(object);
+    return index === -1 ? undefined : index;
+  }
+
+  remove(index: number): void {
+    this.array.splice(index, 1);
+  }
+
+  set(idx: number, object: PDFObject): void {
+    this.array[idx] = object;
+  }
+
+  get(index: number): PDFObject {
+    return this.array[index];
+  }
+
+  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 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 PDFRef): PDFRef | undefined;
+  lookupMaybe(index: number, type: typeof PDFString): PDFString | undefined;
+  lookupMaybe(
+    index: number,
+    type1: typeof PDFString,
+    type2: typeof PDFHexString,
+  ): PDFString | PDFHexString | undefined;
+
+  lookupMaybe(index: number, ...types: any[]) {
+    return this.context.lookupMaybe(
+      this.get(index),
+      // @ts-ignore
+      ...types,
+    ) as any;
+  }
+
+  lookup(index: number): PDFObject | undefined;
+  lookup(index: number, type: typeof PDFArray): PDFArray;
+  lookup(index: number, type: typeof PDFBool): PDFBool;
+  lookup(index: number, type: typeof PDFDict): PDFDict;
+  lookup(index: number, type: typeof PDFHexString): PDFHexString;
+  lookup(index: number, type: typeof PDFName): PDFName;
+  lookup(index: number, type: typeof PDFNull): typeof PDFNull;
+  lookup(index: number, type: typeof PDFNumber): PDFNumber;
+  lookup(index: number, type: typeof PDFStream): PDFStream;
+  lookup(index: number, type: typeof PDFRawStream): PDFRawStream;
+  lookup(index: number, type: typeof PDFRef): PDFRef;
+  lookup(index: number, type: typeof PDFString): PDFString;
+  lookup(
+    index: number,
+    type1: typeof PDFString,
+    type2: typeof PDFHexString,
+  ): PDFString | PDFHexString;
+
+  lookup(index: number, ...types: any[]) {
+    return this.context.lookup(
+      this.get(index),
+      // @ts-ignore
+      ...types,
+    ) as any;
+  }
+
+  asRectangle(): { x: number; y: number; width: number; height: number } {
+    if (this.size() !== 4) throw new PDFArrayIsNotRectangleError(this.size());
+
+    const lowerLeftX = this.lookup(0, PDFNumber).asNumber();
+    const lowerLeftY = this.lookup(1, PDFNumber).asNumber();
+    const upperRightX = this.lookup(2, PDFNumber).asNumber();
+    const upperRightY = this.lookup(3, PDFNumber).asNumber();
+
+    const x = lowerLeftX;
+    const y = lowerLeftY;
+    const width = upperRightX - lowerLeftX;
+    const height = upperRightY - lowerLeftY;
+
+    return { x, y, width, height };
+  }
+
+  asArray(): PDFObject[] {
+    return this.array.slice();
+  }
+
+  clone(context?: PDFContext): PDFArray {
+    const clone = PDFArray.withContext(context || this.context);
+    for (let idx = 0, len = this.size(); idx < len; idx++) {
+      clone.push(this.array[idx]);
+    }
+    return clone;
+  }
+
+  toString(): string {
+    let arrayString = '[ ';
+    for (let idx = 0, len = this.size(); idx < len; idx++) {
+      arrayString += this.get(idx).toString();
+      arrayString += ' ';
+    }
+    arrayString += ']';
+    return arrayString;
+  }
+
+  sizeInBytes(): number {
+    let size = 3;
+    for (let idx = 0, len = this.size(); idx < len; idx++) {
+      size += this.get(idx).sizeInBytes() + 1;
+    }
+    return size;
+  }
+
+  copyBytesInto(buffer: Uint8Array, offset: number): number {
+    const initialOffset = offset;
+
+    buffer[offset++] = CharCodes.LeftSquareBracket;
+    buffer[offset++] = CharCodes.Space;
+    for (let idx = 0, len = this.size(); idx < len; idx++) {
+      offset += this.get(idx).copyBytesInto(buffer, offset);
+      buffer[offset++] = CharCodes.Space;
+    }
+    buffer[offset++] = CharCodes.RightSquareBracket;
+
+    return offset - initialOffset;
+  }
+
+  scalePDFNumbers(x: number, y: number): void {
+    for (let idx = 0, len = this.size(); idx < len; idx++) {
+      const el = this.lookup(idx);
+      if (el instanceof PDFNumber) {
+        const factor = idx % 2 === 0 ? x : y;
+        this.set(idx, PDFNumber.of(el.asNumber() * factor));
+      }
+    }
+  }
+}
+
+export default PDFArray;

package/src/core/objects/PDFBool.ts

@@ -0,0 +1,53 @@
+import { PrivateConstructorError } from '../errors';
+import PDFObject from './PDFObject';
+import CharCodes from '../syntax/CharCodes';
+
+const ENFORCER = {};
+
+class PDFBool extends PDFObject {
+  static readonly True = new PDFBool(ENFORCER, true);
+  static readonly False = new PDFBool(ENFORCER, false);
+
+  private readonly value: boolean;
+
+  private constructor(enforcer: any, value: boolean) {
+    if (enforcer !== ENFORCER) throw new PrivateConstructorError('PDFBool');
+    super();
+    this.value = value;
+  }
+
+  asBoolean(): boolean {
+    return this.value;
+  }
+
+  clone(): PDFBool {
+    return this;
+  }
+
+  toString(): string {
+    return String(this.value);
+  }
+
+  sizeInBytes(): number {
+    return this.value ? 4 : 5;
+  }
+
+  copyBytesInto(buffer: Uint8Array, offset: number): number {
+    if (this.value) {
+      buffer[offset++] = CharCodes.t;
+      buffer[offset++] = CharCodes.r;
+      buffer[offset++] = CharCodes.u;
+      buffer[offset++] = CharCodes.e;
+      return 4;
+    } else {
+      buffer[offset++] = CharCodes.f;
+      buffer[offset++] = CharCodes.a;
+      buffer[offset++] = CharCodes.l;
+      buffer[offset++] = CharCodes.s;
+      buffer[offset++] = CharCodes.e;
+      return 5;
+    }
+  }
+}
+
+export default PDFBool;

package/src/core/objects/PDFDict.ts

@@ -0,0 +1,220 @@
+import PDFArray from './PDFArray';
+import PDFBool from './PDFBool';
+import PDFHexString from './PDFHexString';
+import PDFName from './PDFName';
+import PDFNull from './PDFNull';
+import PDFNumber from './PDFNumber';
+import PDFObject from './PDFObject';
+import PDFRef from './PDFRef';
+import PDFStream from './PDFStream';
+import PDFString from './PDFString';
+import PDFContext from '../PDFContext';
+import CharCodes from '../syntax/CharCodes';
+
+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);
+
+  readonly context: PDFContext;
+
+  private readonly dict: DictMap;
+
+  suppressEncryption: boolean = false;
+
+  protected constructor(map: DictMap, context: PDFContext) {
+    super();
+    this.dict = map;
+    this.context = context;
+  }
+
+  keys(): PDFName[] {
+    return Array.from(this.dict.keys());
+  }
+
+  values(): PDFObject[] {
+    return Array.from(this.dict.values());
+  }
+
+  entries(): [PDFName, PDFObject][] {
+    return Array.from(this.dict.entries());
+  }
+
+  set(key: PDFName, value: PDFObject): void {
+    this.dict.set(key, value);
+  }
+
+  get(
+    key: PDFName,
+    // TODO: `preservePDFNull` is for backwards compatibility. Should be
+    // removed in next breaking API change.
+    preservePDFNull = false,
+  ): PDFObject | undefined {
+    const value = this.dict.get(key);
+    if (value === PDFNull && !preservePDFNull) return undefined;
+    return value;
+  }
+
+  has(key: PDFName): boolean {
+    const value = this.dict.get(key);
+    return value !== undefined && value !== PDFNull;
+  }
+
+  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 PDFName): PDFName | undefined;
+  lookupMaybe(key: PDFName, type: typeof PDFNull): typeof PDFNull | undefined;
+  lookupMaybe(key: PDFName, type: typeof PDFNumber): PDFNumber | undefined;
+  lookupMaybe(key: PDFName, type: typeof PDFStream): PDFStream | undefined;
+  lookupMaybe(key: PDFName, type: typeof PDFRef): PDFRef | undefined;
+  lookupMaybe(key: PDFName, type: typeof PDFString): PDFString | undefined;
+  lookupMaybe(
+    ref: PDFName,
+    type1: typeof PDFString,
+    type2: typeof PDFHexString,
+  ): PDFString | PDFHexString | undefined;
+  lookupMaybe(
+    ref: PDFName,
+    type1: typeof PDFDict,
+    type2: typeof PDFStream,
+  ): PDFDict | PDFStream | undefined;
+  lookupMaybe(
+    ref: PDFName,
+    type1: typeof PDFString,
+    type2: typeof PDFHexString,
+    type3: typeof PDFArray,
+  ): PDFString | PDFHexString | PDFArray | undefined;
+
+  lookupMaybe(key: PDFName, ...types: any[]) {
+    // TODO: `preservePDFNull` is for backwards compatibility. Should be
+    // removed in next breaking API change.
+    const preservePDFNull = types.includes(PDFNull);
+
+    const value = this.context.lookupMaybe(
+      this.get(key, preservePDFNull),
+      // @ts-ignore
+      ...types,
+    ) as any;
+
+    if (value === PDFNull && !preservePDFNull) return undefined;
+
+    return value;
+  }
+
+  lookup(key: PDFName): PDFObject | undefined;
+  lookup(key: PDFName, type: typeof PDFArray): PDFArray;
+  lookup(key: PDFName, type: typeof PDFBool): PDFBool;
+  lookup(key: PDFName, type: typeof PDFDict): PDFDict;
+  lookup(key: PDFName, type: typeof PDFHexString): PDFHexString;
+  lookup(key: PDFName, type: typeof PDFName): PDFName;
+  lookup(key: PDFName, type: typeof PDFNull): typeof PDFNull;
+  lookup(key: PDFName, type: typeof PDFNumber): PDFNumber;
+  lookup(key: PDFName, type: typeof PDFStream): PDFStream;
+  lookup(key: PDFName, type: typeof PDFRef): PDFRef;
+  lookup(key: PDFName, type: typeof PDFString): PDFString;
+  lookup(
+    ref: PDFName,
+    type1: typeof PDFString,
+    type2: typeof PDFHexString,
+  ): PDFString | PDFHexString;
+  lookup(ref: PDFName, type1: typeof PDFDict, type2: typeof PDFStream): PDFDict | PDFStream;
+  lookup(
+    ref: PDFName,
+    type1: typeof PDFString,
+    type2: typeof PDFHexString,
+    type3: typeof PDFArray,
+  ): PDFString | PDFHexString | PDFArray;
+
+  lookup(key: PDFName, ...types: any[]) {
+    // TODO: `preservePDFNull` is for backwards compatibility. Should be
+    // removed in next breaking API change.
+    const preservePDFNull = types.includes(PDFNull);
+
+    const value = this.context.lookup(
+      this.get(key, preservePDFNull),
+      // @ts-ignore
+      ...types,
+    ) as any;
+
+    if (value === PDFNull && !preservePDFNull) return undefined;
+
+    return value;
+  }
+
+  delete(key: PDFName): boolean {
+    return this.dict.delete(key);
+  }
+
+  asMap(): Map<PDFName, PDFObject> {
+    return new Map(this.dict);
+  }
+
+  /** Generate a random key that doesn't exist in current key set */
+  uniqueKey(tag = ''): PDFName {
+    const existingKeys = this.keys();
+    let key = PDFName.of(this.context.addRandomSuffix(tag, 10));
+    while (existingKeys.includes(key)) {
+      key = PDFName.of(this.context.addRandomSuffix(tag, 10));
+    }
+    return key;
+  }
+
+  clone(context?: PDFContext): PDFDict {
+    const clone = PDFDict.withContext(context || this.context);
+    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;
+  }
+
+  toString(): string {
+    let dictString = '<<\n';
+    const entries = this.entries();
+    for (let idx = 0, len = entries.length; idx < len; idx++) {
+      const [key, value] = entries[idx];
+      dictString += key.toString() + ' ' + value.toString() + '\n';
+    }
+    dictString += '>>';
+    return dictString;
+  }
+
+  sizeInBytes(): number {
+    let size = 5;
+    const entries = this.entries();
+    for (let idx = 0, len = entries.length; idx < len; idx++) {
+      const [key, value] = entries[idx];
+      size += key.sizeInBytes() + value.sizeInBytes() + 2;
+    }
+    return size;
+  }
+
+  copyBytesInto(buffer: Uint8Array, offset: number): number {
+    const initialOffset = offset;
+
+    buffer[offset++] = CharCodes.LessThan;
+    buffer[offset++] = CharCodes.LessThan;
+    buffer[offset++] = CharCodes.Newline;
+
+    const entries = this.entries();
+    for (let idx = 0, len = entries.length; idx < len; idx++) {
+      const [key, value] = entries[idx];
+      offset += key.copyBytesInto(buffer, offset);
+      buffer[offset++] = CharCodes.Space;
+      offset += value.copyBytesInto(buffer, offset);
+      buffer[offset++] = CharCodes.Newline;
+    }
+
+    buffer[offset++] = CharCodes.GreaterThan;
+    buffer[offset++] = CharCodes.GreaterThan;
+
+    return offset - initialOffset;
+  }
+}
+
+export default PDFDict;

package/src/core/objects/PDFHexString.ts

@@ -0,0 +1,94 @@
+import PDFObject from './PDFObject';
+import CharCodes from '../syntax/CharCodes';
+import {
+  copyStringIntoBuffer,
+  toHexStringOfMinLength,
+  utf16Decode,
+  utf16Encode,
+  pdfDocEncodingDecode,
+  parseDate,
+  hasUtf16BOM,
+} from '../../utils';
+import { InvalidPDFDateStringError } from '../errors';
+
+class PDFHexString extends PDFObject {
+  static of = (value: string) => new PDFHexString(value);
+
+  static fromText = (value: string) => {
+    const encoded = utf16Encode(value);
+
+    let hex = '';
+    for (let idx = 0, len = encoded.length; idx < len; idx++) {
+      hex += toHexStringOfMinLength(encoded[idx], 4);
+    }
+
+    return new PDFHexString(hex);
+  };
+
+  private readonly value: string;
+
+  constructor(value: string) {
+    super();
+    this.value = value;
+  }
+
+  asBytes(): Uint8Array {
+    // Append a zero if the number of digits is odd. See PDF spec 7.3.4.3
+    const hex = this.value + (this.value.length % 2 === 1 ? '0' : '');
+    const hexLength = hex.length;
+
+    const bytes = new Uint8Array(hex.length / 2);
+
+    let hexOffset = 0;
+    let bytesOffset = 0;
+
+    // Interpret each pair of hex digits as a single byte
+    while (hexOffset < hexLength) {
+      const byte = parseInt(hex.substring(hexOffset, hexOffset + 2), 16);
+      bytes[bytesOffset] = byte;
+
+      hexOffset += 2;
+      bytesOffset += 1;
+    }
+
+    return bytes;
+  }
+
+  decodeText(): string {
+    const bytes = this.asBytes();
+    if (hasUtf16BOM(bytes)) return utf16Decode(bytes);
+    return pdfDocEncodingDecode(bytes);
+  }
+
+  decodeDate(): Date {
+    const text = this.decodeText();
+    const date = parseDate(text);
+    if (!date) throw new InvalidPDFDateStringError(text);
+    return date;
+  }
+
+  asString(): string {
+    return this.value;
+  }
+
+  clone(): PDFHexString {
+    return PDFHexString.of(this.value);
+  }
+
+  toString(): string {
+    return `<${this.value}>`;
+  }
+
+  sizeInBytes(): number {
+    return this.value.length + 2;
+  }
+
+  copyBytesInto(buffer: Uint8Array, offset: number): number {
+    buffer[offset++] = CharCodes.LessThan;
+    offset += copyStringIntoBuffer(this.value, buffer, offset);
+    buffer[offset++] = CharCodes.GreaterThan;
+    return this.value.length + 2;
+  }
+}
+
+export default PDFHexString;

package/src/core/objects/PDFInvalidObject.ts

@@ -0,0 +1,34 @@
+import PDFObject from './PDFObject';
+
+class PDFInvalidObject extends PDFObject {
+  static of = (data: Uint8Array) => new PDFInvalidObject(data);
+
+  private readonly data: Uint8Array;
+
+  private constructor(data: Uint8Array) {
+    super();
+    this.data = data;
+  }
+
+  clone(): PDFInvalidObject {
+    return PDFInvalidObject.of(this.data.slice());
+  }
+
+  toString(): string {
+    return `PDFInvalidObject(${this.data.length} bytes)`;
+  }
+
+  sizeInBytes(): number {
+    return this.data.length;
+  }
+
+  copyBytesInto(buffer: Uint8Array, offset: number): number {
+    const length = this.data.length;
+    for (let idx = 0; idx < length; idx++) {
+      buffer[offset++] = this.data[idx];
+    }
+    return length;
+  }
+}
+
+export default PDFInvalidObject;