@adnsistemas/pdf-lib 1.18.0

package/src/core/objects/PDFName.ts

@@ -0,0 +1,159 @@
+import { PrivateConstructorError } from 'src/core/errors';
+import PDFObject from 'src/core/objects/PDFObject';
+import CharCodes from 'src/core/syntax/CharCodes';
+import { IsIrregular } from 'src/core/syntax/Irregular';
+import {
+  charFromHexCode,
+  copyStringIntoBuffer,
+  toCharCode,
+  toHexString,
+} from 'src/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

@@ -0,0 +1,30 @@
+import PDFObject from 'src/core/objects/PDFObject';
+import CharCodes from 'src/core/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

@@ -0,0 +1,44 @@
+import { copyStringIntoBuffer, numberToString } from 'src/utils/index';
+
+import PDFObject from 'src/core/objects/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

@@ -0,0 +1,28 @@
+import { MethodNotImplementedError } from 'src/core/errors';
+import PDFContext from 'src/core/PDFContext';
+
+class PDFObject {
+  registerChange() {
+    throw new MethodNotImplementedError(
+      this.constructor.name,
+      'registerChange',
+    );
+  }
+  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

@@ -0,0 +1,38 @@
+import PDFDict from 'src/core/objects/PDFDict';
+import PDFStream from 'src/core/objects/PDFStream';
+import PDFContext from 'src/core/PDFContext';
+import { arrayAsString } from 'src/utils';
+
+class PDFRawStream extends PDFStream {
+  static of = (dict: PDFDict, contents: Uint8Array) =>
+    new PDFRawStream(dict, contents);
+
+  readonly contents: Uint8Array;
+
+  private constructor(dict: PDFDict, contents: Uint8Array) {
+    super(dict);
+    this.contents = contents;
+  }
+
+  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

@@ -0,0 +1,55 @@
+import { PrivateConstructorError } from 'src/core/errors';
+import PDFObject from 'src/core/objects/PDFObject';
+import { copyStringIntoBuffer } from 'src/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

@@ -0,0 +1,93 @@
+import { MethodNotImplementedError } from 'src/core/errors';
+import PDFDict from 'src/core/objects/PDFDict';
+import PDFName from 'src/core/objects/PDFName';
+import PDFNumber from 'src/core/objects/PDFNumber';
+import PDFObject from 'src/core/objects/PDFObject';
+import PDFContext from 'src/core/PDFContext';
+import CharCodes from 'src/core/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

@@ -0,0 +1,118 @@
+import PDFObject from 'src/core/objects/PDFObject';
+import CharCodes from 'src/core/syntax/CharCodes';
+import {
+  copyStringIntoBuffer,
+  padStart,
+  utf16Decode,
+  pdfDocEncodingDecode,
+  toCharCode,
+  parseDate,
+  hasUtf16BOM,
+} from 'src/utils';
+import { InvalidPDFDateStringError } from 'src/core/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

@@ -0,0 +1,79 @@
+import PDFArray from 'src/core/objects/PDFArray';
+import PDFHexString from 'src/core/objects/PDFHexString';
+import PDFName from 'src/core/objects/PDFName';
+import PDFNumber from 'src/core/objects/PDFNumber';
+import PDFObject from 'src/core/objects/PDFObject';
+import PDFString from 'src/core/objects/PDFString';
+import PDFOperatorNames from 'src/core/operators/PDFOperatorNames';
+import PDFContext from 'src/core/PDFContext';
+import CharCodes from 'src/core/syntax/CharCodes';
+import { copyStringIntoBuffer } from 'src/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 = new 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;