@pdfme/pdf-lib 0.0.0

package/src/core/operators/PDFOperatorNames.ts

@@ -0,0 +1,92 @@
+enum PDFOperatorNames {
+  // Non Stroking Color Operators
+  NonStrokingColor = 'sc',
+  NonStrokingColorN = 'scn',
+  NonStrokingColorRgb = 'rg',
+  NonStrokingColorGray = 'g',
+  NonStrokingColorCmyk = 'k',
+  NonStrokingColorspace = 'cs',
+
+  // Stroking Color Operators
+  StrokingColor = 'SC',
+  StrokingColorN = 'SCN',
+  StrokingColorRgb = 'RG',
+  StrokingColorGray = 'G',
+  StrokingColorCmyk = 'K',
+  StrokingColorspace = 'CS',
+
+  // Marked Content Operators
+  BeginMarkedContentSequence = 'BDC',
+  BeginMarkedContent = 'BMC',
+  EndMarkedContent = 'EMC',
+  MarkedContentPointWithProps = 'DP',
+  MarkedContentPoint = 'MP',
+  DrawObject = 'Do',
+
+  // Graphics State Operators
+  ConcatTransformationMatrix = 'cm',
+  PopGraphicsState = 'Q',
+  PushGraphicsState = 'q',
+  SetFlatness = 'i',
+  SetGraphicsStateParams = 'gs',
+  SetLineCapStyle = 'J',
+  SetLineDashPattern = 'd',
+  SetLineJoinStyle = 'j',
+  SetLineMiterLimit = 'M',
+  SetLineWidth = 'w',
+  SetTextMatrix = 'Tm',
+  SetRenderingIntent = 'ri',
+
+  // Graphics Operators
+  AppendRectangle = 're',
+  BeginInlineImage = 'BI',
+  BeginInlineImageData = 'ID',
+  EndInlineImage = 'EI',
+  ClipEvenOdd = 'W*',
+  ClipNonZero = 'W',
+  CloseAndStroke = 's',
+  CloseFillEvenOddAndStroke = 'b*',
+  CloseFillNonZeroAndStroke = 'b',
+  ClosePath = 'h',
+  AppendBezierCurve = 'c',
+  CurveToReplicateFinalPoint = 'y',
+  CurveToReplicateInitialPoint = 'v',
+  EndPath = 'n',
+  FillEvenOddAndStroke = 'B*',
+  FillEvenOdd = 'f*',
+  FillNonZeroAndStroke = 'B',
+  FillNonZero = 'f',
+  LegacyFillNonZero = 'F',
+  LineTo = 'l',
+  MoveTo = 'm',
+  ShadingFill = 'sh',
+  StrokePath = 'S',
+
+  // Text Operators
+  BeginText = 'BT',
+  EndText = 'ET',
+  MoveText = 'Td',
+  MoveTextSetLeading = 'TD',
+  NextLine = 'T*',
+  SetCharacterSpacing = 'Tc',
+  SetFontAndSize = 'Tf',
+  SetTextHorizontalScaling = 'Tz',
+  SetTextLineHeight = 'TL',
+  SetTextRenderingMode = 'Tr',
+  SetTextRise = 'Ts',
+  SetWordSpacing = 'Tw',
+  ShowText = 'Tj',
+  ShowTextAdjusted = 'TJ',
+  ShowTextLine = "'", // tslint:disable-line quotemark
+  ShowTextLineAndSpace = '"',
+
+  // Type3 Font Operators
+  Type3D0 = 'd0',
+  Type3D1 = 'd1',
+
+  // Compatibility Section Operators
+  BeginCompatibilitySection = 'BX',
+  EndCompatibilitySection = 'EX',
+}
+
+export default PDFOperatorNames;

package/src/core/parser/BaseParser.ts

@@ -0,0 +1,119 @@
+import { NumberParsingError } from '../errors';
+import ByteStream from '../parser/ByteStream';
+import CharCodes from '../syntax/CharCodes';
+import { IsDigit, IsNumeric } from '../syntax/Numeric';
+import { IsWhitespace } from '../syntax/Whitespace';
+import { charFromCode } from '../../utils';
+
+const { Newline, CarriageReturn } = CharCodes;
+
+// TODO: Throw error if eof is reached before finishing object parse...
+class BaseParser {
+  protected readonly bytes: ByteStream;
+  protected readonly capNumbers: boolean;
+
+  constructor(bytes: ByteStream, capNumbers = false) {
+    this.bytes = bytes;
+    this.capNumbers = capNumbers;
+  }
+
+  protected parseRawInt(): number {
+    let value = '';
+
+    while (!this.bytes.done()) {
+      const byte = this.bytes.peek();
+      if (!IsDigit[byte]) break;
+      value += charFromCode(this.bytes.next());
+    }
+
+    const numberValue = Number(value);
+
+    if (!value || !isFinite(numberValue)) {
+      throw new NumberParsingError(this.bytes.position(), value);
+    }
+
+    return numberValue;
+  }
+
+  // TODO: Maybe handle exponential format?
+  // TODO: Compare performance of string concatenation to charFromCode(...bytes)
+  protected parseRawNumber(): number {
+    let value = '';
+
+    // Parse integer-part, the leading (+ | - | . | 0-9)
+    while (!this.bytes.done()) {
+      const byte = this.bytes.peek();
+      if (!IsNumeric[byte]) break;
+      value += charFromCode(this.bytes.next());
+      if (byte === CharCodes.Period) break;
+    }
+
+    // Parse decimal-part, the trailing (0-9)
+    while (!this.bytes.done()) {
+      const byte = this.bytes.peek();
+      if (!IsDigit[byte]) break;
+      value += charFromCode(this.bytes.next());
+    }
+
+    const numberValue = Number(value);
+
+    if (!value || !isFinite(numberValue)) {
+      throw new NumberParsingError(this.bytes.position(), value);
+    }
+
+    if (numberValue > Number.MAX_SAFE_INTEGER) {
+      if (this.capNumbers) {
+        const msg = `Parsed number that is too large for some PDF readers: ${value}, using Number.MAX_SAFE_INTEGER instead.`;
+        console.warn(msg);
+        return Number.MAX_SAFE_INTEGER;
+      } else {
+        const msg = `Parsed number that is too large for some PDF readers: ${value}, not capping.`;
+        console.warn(msg);
+      }
+    }
+
+    return numberValue;
+  }
+
+  protected skipWhitespace(): void {
+    while (!this.bytes.done() && IsWhitespace[this.bytes.peek()]) {
+      this.bytes.next();
+    }
+  }
+
+  protected skipLine(): void {
+    while (!this.bytes.done()) {
+      const byte = this.bytes.peek();
+      if (byte === Newline || byte === CarriageReturn) return;
+      this.bytes.next();
+    }
+  }
+
+  protected skipComment(): boolean {
+    if (this.bytes.peek() !== CharCodes.Percent) return false;
+    while (!this.bytes.done()) {
+      const byte = this.bytes.peek();
+      if (byte === Newline || byte === CarriageReturn) return true;
+      this.bytes.next();
+    }
+    return true;
+  }
+
+  protected skipWhitespaceAndComments(): void {
+    this.skipWhitespace();
+    while (this.skipComment()) this.skipWhitespace();
+  }
+
+  protected matchKeyword(keyword: number[]): boolean {
+    const initialOffset = this.bytes.offset();
+    for (let idx = 0, len = keyword.length; idx < len; idx++) {
+      if (this.bytes.done() || this.bytes.next() !== keyword[idx]) {
+        this.bytes.moveTo(initialOffset);
+        return false;
+      }
+    }
+    return true;
+  }
+}
+
+export default BaseParser;

package/src/core/parser/ByteStream.ts

@@ -0,0 +1,76 @@
+import { NextByteAssertionError } from '../errors';
+import PDFRawStream from '../objects/PDFRawStream';
+import { decodePDFRawStream } from '../streams/decode';
+import CharCodes from '../syntax/CharCodes';
+
+// TODO: See how line/col tracking affects performance
+class ByteStream {
+  static of = (bytes: Uint8Array) => new ByteStream(bytes);
+
+  static fromPDFRawStream = (rawStream: PDFRawStream) =>
+    ByteStream.of(decodePDFRawStream(rawStream).decode());
+
+  private readonly bytes: Uint8Array;
+  private readonly length: number;
+
+  private idx = 0;
+  private line = 0;
+  private column = 0;
+
+  constructor(bytes: Uint8Array) {
+    this.bytes = bytes;
+    this.length = this.bytes.length;
+  }
+
+  moveTo(offset: number): void {
+    this.idx = offset;
+  }
+
+  next(): number {
+    const byte = this.bytes[this.idx++];
+    if (byte === CharCodes.Newline) {
+      this.line += 1;
+      this.column = 0;
+    } else {
+      this.column += 1;
+    }
+    return byte;
+  }
+
+  assertNext(expected: number): number {
+    if (this.peek() !== expected) {
+      throw new NextByteAssertionError(this.position(), expected, this.peek());
+    }
+    return this.next();
+  }
+
+  peek(): number {
+    return this.bytes[this.idx];
+  }
+
+  peekAhead(steps: number) {
+    return this.bytes[this.idx + steps];
+  }
+
+  peekAt(offset: number) {
+    return this.bytes[offset];
+  }
+
+  done(): boolean {
+    return this.idx >= this.length;
+  }
+
+  offset(): number {
+    return this.idx;
+  }
+
+  slice(start: number, end: number): Uint8Array {
+    return this.bytes.slice(start, end);
+  }
+
+  position(): { line: number; column: number; offset: number } {
+    return { line: this.line, column: this.column, offset: this.idx };
+  }
+}
+
+export default ByteStream;

package/src/core/parser/PDFObjectParser.ts

@@ -0,0 +1,302 @@
+import {
+  PDFObjectParsingError,
+  PDFStreamParsingError,
+  Position,
+  UnbalancedParenthesisError,
+} from '../errors';
+import PDFArray from '../objects/PDFArray';
+import PDFBool from '../objects/PDFBool';
+import PDFDict, { DictMap } from '../objects/PDFDict';
+import PDFHexString from '../objects/PDFHexString';
+import PDFName from '../objects/PDFName';
+import PDFNull from '../objects/PDFNull';
+import PDFNumber from '../objects/PDFNumber';
+import PDFObject from '../objects/PDFObject';
+import PDFRawStream from '../objects/PDFRawStream';
+import PDFRef from '../objects/PDFRef';
+import PDFStream from '../objects/PDFStream';
+import PDFString from '../objects/PDFString';
+import BaseParser from './BaseParser';
+import ByteStream from './ByteStream';
+import PDFContext from '../PDFContext';
+import PDFCatalog from '../structures/PDFCatalog';
+import PDFPageLeaf from '../structures/PDFPageLeaf';
+import PDFPageTree from '../structures/PDFPageTree';
+import CharCodes from '../syntax/CharCodes';
+import { IsDelimiter } from '../syntax/Delimiters';
+import { Keywords } from '../syntax/Keywords';
+import { IsDigit, IsNumeric } from '../syntax/Numeric';
+import { IsWhitespace } from '../syntax/Whitespace';
+import { charFromCode } from '../../utils';
+import { CipherTransformFactory } from '../crypto';
+
+// TODO: Throw error if eof is reached before finishing object parse...
+class PDFObjectParser extends BaseParser {
+  static forBytes = (bytes: Uint8Array, context: PDFContext, capNumbers?: boolean) =>
+    new PDFObjectParser(ByteStream.of(bytes), context, capNumbers);
+
+  static forByteStream = (byteStream: ByteStream, context: PDFContext, capNumbers = false) =>
+    new PDFObjectParser(byteStream, context, capNumbers);
+
+  protected readonly context: PDFContext;
+  private readonly cryptoFactory?: CipherTransformFactory;
+
+  constructor(
+    byteStream: ByteStream,
+    context: PDFContext,
+    capNumbers = false,
+    cryptoFactory?: CipherTransformFactory,
+  ) {
+    super(byteStream, capNumbers);
+    this.context = context;
+    this.cryptoFactory = cryptoFactory;
+  }
+
+  // TODO: Is it possible to reduce duplicate parsing for ref lookaheads?
+  parseObject(ref?: PDFRef): PDFObject {
+    this.skipWhitespaceAndComments();
+
+    if (this.matchKeyword(Keywords.true)) return PDFBool.True;
+    if (this.matchKeyword(Keywords.false)) return PDFBool.False;
+    if (this.matchKeyword(Keywords.null)) return PDFNull;
+
+    const byte = this.bytes.peek();
+
+    if (byte === CharCodes.LessThan && this.bytes.peekAhead(1) === CharCodes.LessThan) {
+      return this.parseDictOrStream(ref);
+    }
+    if (byte === CharCodes.LessThan) return this.parseHexString(ref);
+    if (byte === CharCodes.LeftParen) return this.parseString(ref);
+    if (byte === CharCodes.ForwardSlash) return this.parseName();
+    if (byte === CharCodes.LeftSquareBracket) return this.parseArray(ref);
+    if (IsNumeric[byte]) return this.parseNumberOrRef();
+
+    throw new PDFObjectParsingError(this.bytes.position(), byte);
+  }
+
+  protected parseNumberOrRef(): PDFNumber | PDFRef {
+    const firstNum = this.parseRawNumber();
+    this.skipWhitespaceAndComments();
+
+    const lookaheadStart = this.bytes.offset();
+    if (IsDigit[this.bytes.peek()]) {
+      const secondNum = this.parseRawNumber();
+      this.skipWhitespaceAndComments();
+      if (this.bytes.peek() === CharCodes.R) {
+        this.bytes.assertNext(CharCodes.R);
+        return PDFRef.of(firstNum, secondNum);
+      }
+    }
+
+    this.bytes.moveTo(lookaheadStart);
+    return PDFNumber.of(firstNum);
+  }
+
+  // TODO: Maybe update PDFHexString.of() logic to remove whitespace and validate input?
+  protected parseHexString(ref?: PDFRef): PDFHexString {
+    let value = '';
+
+    this.bytes.assertNext(CharCodes.LessThan);
+    while (!this.bytes.done() && this.bytes.peek() !== CharCodes.GreaterThan) {
+      value += charFromCode(this.bytes.next());
+    }
+    this.bytes.assertNext(CharCodes.GreaterThan);
+
+    if (this.cryptoFactory && ref) {
+      const transformer = this.cryptoFactory.createCipherTransform(
+        ref.objectNumber,
+        ref.generationNumber,
+      );
+      const arr = transformer.decryptBytes(PDFHexString.of(value).asBytes());
+      value = arr.reduce(
+        (str: string, byte: number) => str + byte.toString(16).padStart(2, '0'),
+        '',
+      );
+    }
+
+    return PDFHexString.of(value);
+  }
+
+  protected parseString(ref?: PDFRef): PDFString {
+    let nestingLvl = 0;
+    let isEscaped = false;
+    let value = '';
+
+    while (!this.bytes.done()) {
+      const byte = this.bytes.next();
+      value += charFromCode(byte);
+
+      // Check for unescaped parenthesis
+      if (!isEscaped) {
+        if (byte === CharCodes.LeftParen) nestingLvl += 1;
+        if (byte === CharCodes.RightParen) nestingLvl -= 1;
+      }
+
+      // Track whether current character is being escaped or not
+      if (byte === CharCodes.BackSlash) {
+        isEscaped = !isEscaped;
+      } else if (isEscaped) {
+        isEscaped = false;
+      }
+
+      // Once (if) the unescaped parenthesis balance out, return their contents
+      if (nestingLvl === 0) {
+        let actualValue = value.substring(1, value.length - 1);
+
+        if (this.cryptoFactory && ref) {
+          const transformer = this.cryptoFactory.createCipherTransform(
+            ref.objectNumber,
+            ref.generationNumber,
+          );
+          actualValue = transformer.decryptString(actualValue);
+        }
+        // Remove the outer parens so they aren't part of the contents
+        return PDFString.of(actualValue);
+      }
+    }
+
+    throw new UnbalancedParenthesisError(this.bytes.position());
+  }
+
+  // TODO: Compare performance of string concatenation to charFromCode(...bytes)
+  // TODO: Maybe preallocate small Uint8Array if can use charFromCode?
+  protected parseName(): PDFName {
+    this.bytes.assertNext(CharCodes.ForwardSlash);
+
+    let name = '';
+    while (!this.bytes.done()) {
+      const byte = this.bytes.peek();
+      if (IsWhitespace[byte] || IsDelimiter[byte]) break;
+      name += charFromCode(byte);
+      this.bytes.next();
+    }
+
+    return PDFName.of(name);
+  }
+
+  protected parseArray(ref?: PDFRef): PDFArray {
+    this.bytes.assertNext(CharCodes.LeftSquareBracket);
+    this.skipWhitespaceAndComments();
+
+    const pdfArray = PDFArray.withContext(this.context);
+    while (this.bytes.peek() !== CharCodes.RightSquareBracket) {
+      const element = this.parseObject(ref);
+      pdfArray.push(element);
+      this.skipWhitespaceAndComments();
+    }
+    this.bytes.assertNext(CharCodes.RightSquareBracket);
+    return pdfArray;
+  }
+
+  protected parseDict(ref?: PDFRef): PDFDict {
+    this.bytes.assertNext(CharCodes.LessThan);
+    this.bytes.assertNext(CharCodes.LessThan);
+    this.skipWhitespaceAndComments();
+
+    const dict: DictMap = new Map();
+
+    while (
+      !this.bytes.done() &&
+      this.bytes.peek() !== CharCodes.GreaterThan &&
+      this.bytes.peekAhead(1) !== CharCodes.GreaterThan
+    ) {
+      const key = this.parseName();
+      const value = this.parseObject(ref);
+      dict.set(key, value);
+      this.skipWhitespaceAndComments();
+    }
+
+    this.skipWhitespaceAndComments();
+    this.bytes.assertNext(CharCodes.GreaterThan);
+    this.bytes.assertNext(CharCodes.GreaterThan);
+
+    const Type = dict.get(PDFName.of('Type'));
+
+    if (Type === PDFName.of('Catalog')) {
+      return PDFCatalog.fromMapWithContext(dict, this.context);
+    } else if (Type === PDFName.of('Pages')) {
+      return PDFPageTree.fromMapWithContext(dict, this.context);
+    } else if (Type === PDFName.of('Page')) {
+      return PDFPageLeaf.fromMapWithContext(dict, this.context);
+    } else {
+      return PDFDict.fromMapWithContext(dict, this.context);
+    }
+  }
+
+  protected parseDictOrStream(ref?: PDFRef): PDFDict | PDFStream {
+    const startPos = this.bytes.position();
+
+    const dict = this.parseDict(ref);
+
+    this.skipWhitespaceAndComments();
+
+    if (
+      !this.matchKeyword(Keywords.streamEOF1) &&
+      !this.matchKeyword(Keywords.streamEOF2) &&
+      !this.matchKeyword(Keywords.streamEOF3) &&
+      !this.matchKeyword(Keywords.streamEOF4) &&
+      !this.matchKeyword(Keywords.stream)
+    ) {
+      return dict;
+    }
+
+    const start = this.bytes.offset();
+    let end: number;
+
+    const Length = dict.get(PDFName.of('Length'));
+    if (Length instanceof PDFNumber) {
+      end = start + Length.asNumber();
+      this.bytes.moveTo(end);
+      this.skipWhitespaceAndComments();
+      if (!this.matchKeyword(Keywords.endstream)) {
+        this.bytes.moveTo(start);
+        end = this.findEndOfStreamFallback(startPos);
+      }
+    } else {
+      end = this.findEndOfStreamFallback(startPos);
+    }
+
+    let contents = this.bytes.slice(start, end);
+
+    if (this.cryptoFactory && ref) {
+      const transform = this.cryptoFactory.createCipherTransform(
+        ref.objectNumber,
+        ref.generationNumber,
+      );
+      contents = transform.decryptBytes(contents);
+    }
+
+    return PDFRawStream.of(dict, contents);
+  }
+
+  protected findEndOfStreamFallback(startPos: Position) {
+    // Move to end of stream, while handling nested streams
+    let nestingLvl = 1;
+    let end = this.bytes.offset();
+
+    while (!this.bytes.done()) {
+      end = this.bytes.offset();
+
+      if (this.matchKeyword(Keywords.stream)) {
+        nestingLvl += 1;
+      } else if (
+        this.matchKeyword(Keywords.EOF1endstream) ||
+        this.matchKeyword(Keywords.EOF2endstream) ||
+        this.matchKeyword(Keywords.EOF3endstream) ||
+        this.matchKeyword(Keywords.endstream)
+      ) {
+        nestingLvl -= 1;
+      } else {
+        this.bytes.next();
+      }
+
+      if (nestingLvl === 0) break;
+    }
+
+    if (nestingLvl !== 0) throw new PDFStreamParsingError(startPos);
+
+    return end;
+  }
+}
+
+export default PDFObjectParser;

package/src/core/parser/PDFObjectStreamParser.ts

@@ -0,0 +1,65 @@
+import { ReparseError } from '../errors';
+import PDFName from '../objects/PDFName';
+import PDFNumber from '../objects/PDFNumber';
+import PDFRawStream from '../objects/PDFRawStream';
+import PDFRef from '../objects/PDFRef';
+import ByteStream from './ByteStream';
+import PDFObjectParser from './PDFObjectParser';
+import { waitForTick } from '../../utils';
+
+class PDFObjectStreamParser extends PDFObjectParser {
+  static forStream = (rawStream: PDFRawStream, shouldWaitForTick?: () => boolean) =>
+    new PDFObjectStreamParser(rawStream, shouldWaitForTick);
+
+  private alreadyParsed: boolean;
+  private readonly shouldWaitForTick: () => boolean;
+  private readonly firstOffset: number;
+  private readonly objectCount: number;
+
+  constructor(rawStream: PDFRawStream, shouldWaitForTick?: () => boolean) {
+    super(ByteStream.fromPDFRawStream(rawStream), rawStream.dict.context);
+
+    const { dict } = rawStream;
+
+    this.alreadyParsed = false;
+    this.shouldWaitForTick = shouldWaitForTick || (() => false);
+    this.firstOffset = dict.lookup(PDFName.of('First'), PDFNumber).asNumber();
+    this.objectCount = dict.lookup(PDFName.of('N'), PDFNumber).asNumber();
+  }
+
+  async parseIntoContext(): Promise<void> {
+    if (this.alreadyParsed) {
+      throw new ReparseError('PDFObjectStreamParser', 'parseIntoContext');
+    }
+    this.alreadyParsed = true;
+
+    const offsetsAndObjectNumbers = this.parseOffsetsAndObjectNumbers();
+    for (let idx = 0, len = offsetsAndObjectNumbers.length; idx < len; idx++) {
+      const { objectNumber, offset } = offsetsAndObjectNumbers[idx];
+      this.bytes.moveTo(this.firstOffset + offset);
+      const ref = PDFRef.of(objectNumber, 0);
+      const object = this.parseObject(ref);
+      this.context.assign(ref, object);
+      if (this.shouldWaitForTick()) await waitForTick();
+    }
+  }
+
+  private parseOffsetsAndObjectNumbers(): {
+    objectNumber: number;
+    offset: number;
+  }[] {
+    const offsetsAndObjectNumbers = [];
+    for (let idx = 0, len = this.objectCount; idx < len; idx++) {
+      this.skipWhitespaceAndComments();
+      const objectNumber = this.parseRawInt();
+
+      this.skipWhitespaceAndComments();
+      const offset = this.parseRawInt();
+
+      offsetsAndObjectNumbers.push({ objectNumber, offset });
+    }
+    return offsetsAndObjectNumbers;
+  }
+}
+
+export default PDFObjectStreamParser;