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

package/src/core/objects/PDFName.ts

@@ -1,152 +0,0 @@
-import { PrivateConstructorError } from '../errors';
-import PDFObject from './PDFObject';
-import CharCodes from '../syntax/CharCodes';
-import { IsIrregular } from '../syntax/Irregular';
-import { charFromHexCode, copyStringIntoBuffer, toCharCode, toHexString } from '../../utils';
-
-const decodeName = (name: string) =>
-  name.replace(/#([\dABCDEF]{2})/g, (_, hex) => charFromHexCode(hex));
-
-const isRegularChar = (charCode: number) =>
-  charCode >= CharCodes.ExclamationPoint && charCode <= CharCodes.Tilde && !IsIrregular[charCode];
-
-const ENFORCER = {};
-const pool = new Map<string, PDFName>();
-
-class PDFName extends PDFObject {
-  static of = (name: string): PDFName => {
-    const decodedValue = decodeName(name);
-
-    let instance = pool.get(decodedValue);
-    if (!instance) {
-      instance = new PDFName(ENFORCER, decodedValue);
-      pool.set(decodedValue, instance);
-    }
-
-    return instance;
-  };
-
-  /* tslint:disable member-ordering */
-  static readonly Length = PDFName.of('Length');
-  static readonly FlateDecode = PDFName.of('FlateDecode');
-  static readonly Resources = PDFName.of('Resources');
-  static readonly Font = PDFName.of('Font');
-  static readonly XObject = PDFName.of('XObject');
-  static readonly ExtGState = PDFName.of('ExtGState');
-  static readonly Contents = PDFName.of('Contents');
-  static readonly Type = PDFName.of('Type');
-  static readonly Parent = PDFName.of('Parent');
-  static readonly MediaBox = PDFName.of('MediaBox');
-  static readonly Page = PDFName.of('Page');
-  static readonly Annots = PDFName.of('Annots');
-  static readonly TrimBox = PDFName.of('TrimBox');
-  static readonly ArtBox = PDFName.of('ArtBox');
-  static readonly BleedBox = PDFName.of('BleedBox');
-  static readonly CropBox = PDFName.of('CropBox');
-  static readonly Rotate = PDFName.of('Rotate');
-  static readonly Title = PDFName.of('Title');
-  static readonly Author = PDFName.of('Author');
-  static readonly Subject = PDFName.of('Subject');
-  static readonly Creator = PDFName.of('Creator');
-  static readonly Keywords = PDFName.of('Keywords');
-  static readonly Producer = PDFName.of('Producer');
-  static readonly CreationDate = PDFName.of('CreationDate');
-  static readonly ModDate = PDFName.of('ModDate');
-  /* tslint:enable member-ordering */
-
-  private readonly encodedName: string;
-
-  private constructor(enforcer: any, name: string) {
-    if (enforcer !== ENFORCER) throw new PrivateConstructorError('PDFName');
-    super();
-
-    let encodedName = '/';
-    for (let idx = 0, len = name.length; idx < len; idx++) {
-      const character = name[idx];
-      const code = toCharCode(character);
-      encodedName += isRegularChar(code) ? character : `#${toHexString(code)}`;
-    }
-
-    this.encodedName = encodedName;
-  }
-
-  asBytes(): Uint8Array {
-    const bytes: number[] = [];
-
-    let hex = '';
-    let escaped = false;
-
-    const pushByte = (byte?: number) => {
-      if (byte !== undefined) bytes.push(byte);
-      escaped = false;
-    };
-
-    for (let idx = 1, len = this.encodedName.length; idx < len; idx++) {
-      const char = this.encodedName[idx];
-      const byte = toCharCode(char);
-      const nextChar = this.encodedName[idx + 1];
-      if (!escaped) {
-        if (byte === CharCodes.Hash) escaped = true;
-        else pushByte(byte);
-      } else {
-        if (
-          (byte >= CharCodes.Zero && byte <= CharCodes.Nine) ||
-          (byte >= CharCodes.a && byte <= CharCodes.f) ||
-          (byte >= CharCodes.A && byte <= CharCodes.F)
-        ) {
-          hex += char;
-          if (
-            hex.length === 2 ||
-            !(
-              (nextChar >= '0' && nextChar <= '9') ||
-              (nextChar >= 'a' && nextChar <= 'f') ||
-              (nextChar >= 'A' && nextChar <= 'F')
-            )
-          ) {
-            pushByte(parseInt(hex, 16));
-            hex = '';
-          }
-        } else {
-          pushByte(byte);
-        }
-      }
-    }
-
-    return new Uint8Array(bytes);
-  }
-
-  // TODO: This should probably use `utf8Decode()`
-  // TODO: Polyfill Array.from?
-  decodeText(): string {
-    const bytes = this.asBytes();
-    return String.fromCharCode(...Array.from(bytes));
-  }
-
-  asString(): string {
-    return this.encodedName;
-  }
-
-  /** @deprecated in favor of [[PDFName.asString]] */
-  value(): string {
-    return this.encodedName;
-  }
-
-  clone(): PDFName {
-    return this;
-  }
-
-  toString(): string {
-    return this.encodedName;
-  }
-
-  sizeInBytes(): number {
-    return this.encodedName.length;
-  }
-
-  copyBytesInto(buffer: Uint8Array, offset: number): number {
-    offset += copyStringIntoBuffer(this.encodedName, buffer, offset);
-    return this.encodedName.length;
-  }
-}
-
-export default PDFName;

package/src/core/objects/PDFNull.ts

@@ -1,30 +0,0 @@
-import PDFObject from './PDFObject';
-import CharCodes from '../syntax/CharCodes';
-
-class PDFNull extends PDFObject {
-  asNull(): null {
-    return null;
-  }
-
-  clone(): PDFNull {
-    return this;
-  }
-
-  toString(): string {
-    return 'null';
-  }
-
-  sizeInBytes(): number {
-    return 4;
-  }
-
-  copyBytesInto(buffer: Uint8Array, offset: number): number {
-    buffer[offset++] = CharCodes.n;
-    buffer[offset++] = CharCodes.u;
-    buffer[offset++] = CharCodes.l;
-    buffer[offset++] = CharCodes.l;
-    return 4;
-  }
-}
-
-export default new PDFNull();

package/src/core/objects/PDFNumber.ts

@@ -1,44 +0,0 @@
-import { copyStringIntoBuffer, numberToString } from '../../utils/index';
-
-import PDFObject from './PDFObject';
-
-class PDFNumber extends PDFObject {
-  static of = (value: number) => new PDFNumber(value);
-
-  private readonly numberValue: number;
-  private readonly stringValue: string;
-
-  private constructor(value: number) {
-    super();
-    this.numberValue = value;
-    this.stringValue = numberToString(value);
-  }
-
-  asNumber(): number {
-    return this.numberValue;
-  }
-
-  /** @deprecated in favor of [[PDFNumber.asNumber]] */
-  value(): number {
-    return this.numberValue;
-  }
-
-  clone(): PDFNumber {
-    return PDFNumber.of(this.numberValue);
-  }
-
-  toString(): string {
-    return this.stringValue;
-  }
-
-  sizeInBytes(): number {
-    return this.stringValue.length;
-  }
-
-  copyBytesInto(buffer: Uint8Array, offset: number): number {
-    offset += copyStringIntoBuffer(this.stringValue, buffer, offset);
-    return this.stringValue.length;
-  }
-}
-
-export default PDFNumber;

package/src/core/objects/PDFObject.ts

@@ -1,22 +0,0 @@
-import { MethodNotImplementedError } from '../errors';
-import PDFContext from '../PDFContext';
-
-class PDFObject {
-  clone(_context?: PDFContext): PDFObject {
-    throw new MethodNotImplementedError(this.constructor.name, 'clone');
-  }
-
-  toString(): string {
-    throw new MethodNotImplementedError(this.constructor.name, 'toString');
-  }
-
-  sizeInBytes(): number {
-    throw new MethodNotImplementedError(this.constructor.name, 'sizeInBytes');
-  }
-
-  copyBytesInto(_buffer: Uint8Array, _offset: number): number {
-    throw new MethodNotImplementedError(this.constructor.name, 'copyBytesInto');
-  }
-}
-
-export default PDFObject;

package/src/core/objects/PDFRawStream.ts

@@ -1,41 +0,0 @@
-import PDFDict from './PDFDict';
-import PDFStream from './PDFStream';
-import PDFContext from '../PDFContext';
-import { arrayAsString } from '../../utils';
-import { CipherTransform } from '../crypto';
-
-class PDFRawStream extends PDFStream {
-  static of = (dict: PDFDict, contents: Uint8Array, transform?: CipherTransform) =>
-    new PDFRawStream(dict, contents, transform);
-
-  readonly contents: Uint8Array;
-  readonly transform?: CipherTransform;
-
-  private constructor(dict: PDFDict, contents: Uint8Array, transform?: CipherTransform) {
-    super(dict);
-    this.contents = contents;
-    this.transform = transform;
-  }
-
-  asUint8Array(): Uint8Array {
-    return this.contents.slice();
-  }
-
-  clone(context?: PDFContext): PDFRawStream {
-    return PDFRawStream.of(this.dict.clone(context), this.contents.slice());
-  }
-
-  getContentsString(): string {
-    return arrayAsString(this.contents);
-  }
-
-  getContents(): Uint8Array {
-    return this.contents;
-  }
-
-  getContentsSize(): number {
-    return this.contents.length;
-  }
-}
-
-export default PDFRawStream;

package/src/core/objects/PDFRef.ts

@@ -1,51 +0,0 @@
-import { PrivateConstructorError } from '../errors';
-import PDFObject from '../objects/PDFObject';
-import { copyStringIntoBuffer } from '../../utils';
-
-const ENFORCER = {};
-const pool = new Map<string, PDFRef>();
-
-class PDFRef extends PDFObject {
-  static of = (objectNumber: number, generationNumber = 0) => {
-    const tag = `${objectNumber} ${generationNumber} R`;
-
-    let instance = pool.get(tag);
-    if (!instance) {
-      instance = new PDFRef(ENFORCER, objectNumber, generationNumber);
-      pool.set(tag, instance);
-    }
-
-    return instance;
-  };
-
-  readonly objectNumber: number;
-  readonly generationNumber: number;
-  readonly tag: string;
-
-  private constructor(enforcer: any, objectNumber: number, generationNumber: number) {
-    if (enforcer !== ENFORCER) throw new PrivateConstructorError('PDFRef');
-    super();
-    this.objectNumber = objectNumber;
-    this.generationNumber = generationNumber;
-    this.tag = `${objectNumber} ${generationNumber} R`;
-  }
-
-  clone(): PDFRef {
-    return this;
-  }
-
-  toString(): string {
-    return this.tag;
-  }
-
-  sizeInBytes(): number {
-    return this.tag.length;
-  }
-
-  copyBytesInto(buffer: Uint8Array, offset: number): number {
-    offset += copyStringIntoBuffer(this.tag, buffer, offset);
-    return this.tag.length;
-  }
-}
-
-export default PDFRef;

package/src/core/objects/PDFStream.ts

@@ -1,87 +0,0 @@
-import { MethodNotImplementedError } from '../errors';
-import PDFDict from './PDFDict';
-import PDFName from './PDFName';
-import PDFNumber from './PDFNumber';
-import PDFObject from './PDFObject';
-import PDFContext from '../PDFContext';
-import CharCodes from '../syntax/CharCodes';
-
-class PDFStream extends PDFObject {
-  readonly dict: PDFDict;
-
-  constructor(dict: PDFDict) {
-    super();
-    this.dict = dict;
-  }
-
-  clone(_context?: PDFContext): PDFStream {
-    throw new MethodNotImplementedError(this.constructor.name, 'clone');
-  }
-
-  getContentsString(): string {
-    throw new MethodNotImplementedError(this.constructor.name, 'getContentsString');
-  }
-
-  getContents(): Uint8Array {
-    throw new MethodNotImplementedError(this.constructor.name, 'getContents');
-  }
-
-  getContentsSize(): number {
-    throw new MethodNotImplementedError(this.constructor.name, 'getContentsSize');
-  }
-
-  updateDict(): void {
-    const contentsSize = this.getContentsSize();
-    this.dict.set(PDFName.Length, PDFNumber.of(contentsSize));
-  }
-
-  sizeInBytes(): number {
-    this.updateDict();
-    return this.dict.sizeInBytes() + this.getContentsSize() + 18;
-  }
-
-  toString(): string {
-    this.updateDict();
-    let streamString = this.dict.toString();
-    streamString += '\nstream\n';
-    streamString += this.getContentsString();
-    streamString += '\nendstream';
-    return streamString;
-  }
-
-  copyBytesInto(buffer: Uint8Array, offset: number): number {
-    this.updateDict();
-    const initialOffset = offset;
-
-    offset += this.dict.copyBytesInto(buffer, offset);
-    buffer[offset++] = CharCodes.Newline;
-
-    buffer[offset++] = CharCodes.s;
-    buffer[offset++] = CharCodes.t;
-    buffer[offset++] = CharCodes.r;
-    buffer[offset++] = CharCodes.e;
-    buffer[offset++] = CharCodes.a;
-    buffer[offset++] = CharCodes.m;
-    buffer[offset++] = CharCodes.Newline;
-
-    const contents = this.getContents();
-    for (let idx = 0, len = contents.length; idx < len; idx++) {
-      buffer[offset++] = contents[idx];
-    }
-
-    buffer[offset++] = CharCodes.Newline;
-    buffer[offset++] = CharCodes.e;
-    buffer[offset++] = CharCodes.n;
-    buffer[offset++] = CharCodes.d;
-    buffer[offset++] = CharCodes.s;
-    buffer[offset++] = CharCodes.t;
-    buffer[offset++] = CharCodes.r;
-    buffer[offset++] = CharCodes.e;
-    buffer[offset++] = CharCodes.a;
-    buffer[offset++] = CharCodes.m;
-
-    return offset - initialOffset;
-  }
-}
-
-export default PDFStream;

package/src/core/objects/PDFString.ts

@@ -1,118 +0,0 @@
-import PDFObject from './PDFObject';
-import CharCodes from '../syntax/CharCodes';
-import {
-  copyStringIntoBuffer,
-  padStart,
-  utf16Decode,
-  pdfDocEncodingDecode,
-  toCharCode,
-  parseDate,
-  hasUtf16BOM,
-} from '../../utils';
-import { InvalidPDFDateStringError } from '../errors';
-
-class PDFString extends PDFObject {
-  // The PDF spec allows newlines and parens to appear directly within a literal
-  // string. These character _may_ be escaped. But they do not _have_ to be. So
-  // for simplicity, we will not bother escaping them.
-  static of = (value: string) => new PDFString(value);
-
-  static fromDate = (date: Date) => {
-    const year = padStart(String(date.getUTCFullYear()), 4, '0');
-    const month = padStart(String(date.getUTCMonth() + 1), 2, '0');
-    const day = padStart(String(date.getUTCDate()), 2, '0');
-    const hours = padStart(String(date.getUTCHours()), 2, '0');
-    const mins = padStart(String(date.getUTCMinutes()), 2, '0');
-    const secs = padStart(String(date.getUTCSeconds()), 2, '0');
-    return new PDFString(`D:${year}${month}${day}${hours}${mins}${secs}Z`);
-  };
-
-  private readonly value: string;
-
-  private constructor(value: string) {
-    super();
-    this.value = value;
-  }
-
-  asBytes(): Uint8Array {
-    const bytes: number[] = [];
-
-    let octal = '';
-    let escaped = false;
-
-    const pushByte = (byte?: number) => {
-      if (byte !== undefined) bytes.push(byte);
-      escaped = false;
-    };
-
-    for (let idx = 0, len = this.value.length; idx < len; idx++) {
-      const char = this.value[idx];
-      const byte = toCharCode(char);
-      const nextChar = this.value[idx + 1];
-      if (!escaped) {
-        if (byte === CharCodes.BackSlash) escaped = true;
-        else pushByte(byte);
-      } else {
-        if (byte === CharCodes.Newline) pushByte();
-        else if (byte === CharCodes.CarriageReturn) pushByte();
-        else if (byte === CharCodes.n) pushByte(CharCodes.Newline);
-        else if (byte === CharCodes.r) pushByte(CharCodes.CarriageReturn);
-        else if (byte === CharCodes.t) pushByte(CharCodes.Tab);
-        else if (byte === CharCodes.b) pushByte(CharCodes.Backspace);
-        else if (byte === CharCodes.f) pushByte(CharCodes.FormFeed);
-        else if (byte === CharCodes.LeftParen) pushByte(CharCodes.LeftParen);
-        else if (byte === CharCodes.RightParen) pushByte(CharCodes.RightParen);
-        else if (byte === CharCodes.Backspace) pushByte(CharCodes.BackSlash);
-        else if (byte >= CharCodes.Zero && byte <= CharCodes.Seven) {
-          octal += char;
-          if (octal.length === 3 || !(nextChar >= '0' && nextChar <= '7')) {
-            pushByte(parseInt(octal, 8));
-            octal = '';
-          }
-        } else {
-          pushByte(byte);
-        }
-      }
-    }
-
-    return new Uint8Array(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(): PDFString {
-    return PDFString.of(this.value);
-  }
-
-  toString(): string {
-    return `(${this.value})`;
-  }
-
-  sizeInBytes(): number {
-    return this.value.length + 2;
-  }
-
-  copyBytesInto(buffer: Uint8Array, offset: number): number {
-    buffer[offset++] = CharCodes.LeftParen;
-    offset += copyStringIntoBuffer(this.value, buffer, offset);
-    buffer[offset++] = CharCodes.RightParen;
-    return this.value.length + 2;
-  }
-}
-
-export default PDFString;

package/src/core/operators/PDFOperator.ts

@@ -1,72 +0,0 @@
-import PDFArray from '../objects/PDFArray';
-import PDFHexString from '../objects/PDFHexString';
-import PDFName from '../objects/PDFName';
-import PDFNumber from '../objects/PDFNumber';
-import PDFObject from '../objects/PDFObject';
-import PDFString from '../objects/PDFString';
-import PDFOperatorNames from './PDFOperatorNames';
-import PDFContext from '../PDFContext';
-import CharCodes from '../syntax/CharCodes';
-import { copyStringIntoBuffer } from '../../utils';
-
-export type PDFOperatorArg = string | PDFName | PDFArray | PDFNumber | PDFString | PDFHexString;
-
-class PDFOperator {
-  static of = (name: PDFOperatorNames, args?: PDFOperatorArg[]) => new PDFOperator(name, args);
-
-  private readonly name: PDFOperatorNames;
-  private readonly args: PDFOperatorArg[];
-
-  private constructor(name: PDFOperatorNames, args?: PDFOperatorArg[]) {
-    this.name = name;
-    this.args = args || [];
-  }
-
-  clone(context?: PDFContext): PDFOperator {
-    const args = Array(this.args.length);
-    for (let idx = 0, len = args.length; idx < len; idx++) {
-      const arg = this.args[idx];
-      args[idx] = arg instanceof PDFObject ? arg.clone(context) : arg;
-    }
-    return PDFOperator.of(this.name, args);
-  }
-
-  toString(): string {
-    let value = '';
-    for (let idx = 0, len = this.args.length; idx < len; idx++) {
-      value += String(this.args[idx]) + ' ';
-    }
-    value += this.name;
-    return value;
-  }
-
-  sizeInBytes(): number {
-    let size = 0;
-    for (let idx = 0, len = this.args.length; idx < len; idx++) {
-      const arg = this.args[idx];
-      size += (arg instanceof PDFObject ? arg.sizeInBytes() : arg.length) + 1;
-    }
-    size += this.name.length;
-    return size;
-  }
-
-  copyBytesInto(buffer: Uint8Array, offset: number): number {
-    const initialOffset = offset;
-
-    for (let idx = 0, len = this.args.length; idx < len; idx++) {
-      const arg = this.args[idx];
-      if (arg instanceof PDFObject) {
-        offset += arg.copyBytesInto(buffer, offset);
-      } else {
-        offset += copyStringIntoBuffer(arg, buffer, offset);
-      }
-      buffer[offset++] = CharCodes.Space;
-    }
-
-    offset += copyStringIntoBuffer(this.name, buffer, offset);
-
-    return offset - initialOffset;
-  }
-}
-
-export default PDFOperator;