@adnsistemas/pdf-lib 1.18.0

package/src/core/parser/PDFParser.ts

@@ -0,0 +1,377 @@
+import PDFCrossRefSection from 'src/core/document/PDFCrossRefSection';
+import PDFHeader from 'src/core/document/PDFHeader';
+import PDFTrailer from 'src/core/document/PDFTrailer';
+import {
+  MissingKeywordError,
+  MissingPDFHeaderError,
+  PDFInvalidObjectParsingError,
+  ReparseError,
+  StalledParserError,
+} from 'src/core/errors';
+import PDFDict from 'src/core/objects/PDFDict';
+import PDFInvalidObject from 'src/core/objects/PDFInvalidObject';
+import PDFName from 'src/core/objects/PDFName';
+import PDFObject from 'src/core/objects/PDFObject';
+import PDFRawStream from 'src/core/objects/PDFRawStream';
+import PDFRef from 'src/core/objects/PDFRef';
+import ByteStream from 'src/core/parser/ByteStream';
+import PDFObjectParser from 'src/core/parser/PDFObjectParser';
+import PDFObjectStreamParser from 'src/core/parser/PDFObjectStreamParser';
+import PDFXRefStreamParser from 'src/core/parser/PDFXRefStreamParser';
+import PDFContext from 'src/core/PDFContext';
+import CharCodes from 'src/core/syntax/CharCodes';
+import { Keywords } from 'src/core/syntax/Keywords';
+import { IsDigit } from 'src/core/syntax/Numeric';
+import { waitForTick } from 'src/utils';
+
+class PDFParser extends PDFObjectParser {
+  static forBytesWithOptions = (
+    pdfBytes: Uint8Array,
+    objectsPerTick?: number,
+    throwOnInvalidObject?: boolean,
+    capNumbers?: boolean,
+    forIncrementalUpdate?: boolean,
+  ) =>
+    new PDFParser(
+      pdfBytes,
+      objectsPerTick,
+      throwOnInvalidObject,
+      capNumbers,
+      forIncrementalUpdate,
+    );
+
+  private readonly objectsPerTick: number;
+  private readonly throwOnInvalidObject: boolean;
+  private alreadyParsed = false;
+  private parsedObjects = 0;
+
+  constructor(
+    pdfBytes: Uint8Array,
+    objectsPerTick = Infinity,
+    throwOnInvalidObject = false,
+    capNumbers = false,
+    forIncrementalUpdate = false,
+  ) {
+    super(ByteStream.of(pdfBytes), PDFContext.create(), capNumbers);
+    this.objectsPerTick = objectsPerTick;
+    this.throwOnInvalidObject = throwOnInvalidObject;
+    this.context.pdfFileDetails.pdfSize = pdfBytes.length;
+    if (forIncrementalUpdate) {
+      this.context.pdfFileDetails.originalBytes = pdfBytes;
+    }
+  }
+
+  async parseDocument(): Promise<PDFContext> {
+    if (this.alreadyParsed) {
+      throw new ReparseError('PDFParser', 'parseDocument');
+    }
+    this.alreadyParsed = true;
+
+    this.context.header = this.parseHeader();
+
+    let prevOffset;
+    while (!this.bytes.done()) {
+      await this.parseDocumentSection();
+      const offset = this.bytes.offset();
+      if (offset === prevOffset) {
+        throw new StalledParserError(this.bytes.position());
+      }
+      prevOffset = offset;
+    }
+
+    this.maybeRecoverRoot();
+
+    if (this.context.lookup(PDFRef.of(0))) {
+      console.warn('Removing parsed object: 0 0 R');
+      this.context.delete(PDFRef.of(0));
+    }
+
+    return this.context;
+  }
+
+  private maybeRecoverRoot(): void {
+    const isValidCatalog = (obj?: PDFObject) =>
+      obj instanceof PDFDict &&
+      obj.lookup(PDFName.of('Type')) === PDFName.of('Catalog');
+
+    const catalog = this.context.lookup(this.context.trailerInfo.Root);
+
+    if (!isValidCatalog(catalog)) {
+      const indirectObjects = this.context.enumerateIndirectObjects();
+      for (let idx = 0, len = indirectObjects.length; idx < len; idx++) {
+        const [ref, object] = indirectObjects[idx];
+        if (isValidCatalog(object)) {
+          this.context.trailerInfo.Root = ref;
+        }
+      }
+    }
+  }
+
+  private parseHeader(): PDFHeader {
+    while (!this.bytes.done()) {
+      if (this.matchKeyword(Keywords.header)) {
+        const major = this.parseRawInt();
+        this.bytes.assertNext(CharCodes.Period);
+        const minor = this.parseRawInt();
+        const header = PDFHeader.forVersion(major, minor);
+        this.skipBinaryHeaderComment();
+        return header;
+      }
+      this.bytes.next();
+    }
+
+    throw new MissingPDFHeaderError(this.bytes.position());
+  }
+
+  private parseIndirectObjectHeader(): PDFRef {
+    this.skipWhitespaceAndComments();
+    const objectNumber = this.parseRawInt();
+
+    this.skipWhitespaceAndComments();
+    const generationNumber = this.parseRawInt();
+
+    this.skipWhitespaceAndComments();
+    if (!this.matchKeyword(Keywords.obj)) {
+      throw new MissingKeywordError(this.bytes.position(), Keywords.obj);
+    }
+
+    return PDFRef.of(objectNumber, generationNumber);
+  }
+
+  private matchIndirectObjectHeader(): boolean {
+    const initialOffset = this.bytes.offset();
+    try {
+      this.parseIndirectObjectHeader();
+      return true;
+    } catch (e) {
+      this.bytes.moveTo(initialOffset);
+      return false;
+    }
+  }
+
+  private shouldWaitForTick = () => {
+    this.parsedObjects += 1;
+    return this.parsedObjects % this.objectsPerTick === 0;
+  };
+
+  private async parseIndirectObject(): Promise<PDFRef> {
+    const ref = this.parseIndirectObjectHeader();
+
+    this.skipWhitespaceAndComments();
+    const object = this.parseObject();
+
+    this.skipWhitespaceAndComments();
+    // if (!this.matchKeyword(Keywords.endobj)) {
+    // throw new MissingKeywordError(this.bytes.position(), Keywords.endobj);
+    // }
+
+    // TODO: Log a warning if this fails...
+    this.matchKeyword(Keywords.endobj);
+
+    if (
+      object instanceof PDFRawStream &&
+      object.dict.lookup(PDFName.of('Type')) === PDFName.of('ObjStm')
+    ) {
+      await PDFObjectStreamParser.forStream(
+        object,
+        this.shouldWaitForTick,
+      ).parseIntoContext();
+    } else if (
+      object instanceof PDFRawStream &&
+      object.dict.lookup(PDFName.of('Type')) === PDFName.of('XRef')
+    ) {
+      PDFXRefStreamParser.forStream(object).parseIntoContext();
+    } else {
+      this.context.assign(ref, object);
+    }
+
+    return ref;
+  }
+
+  // TODO: Improve and clean this up
+  private tryToParseInvalidIndirectObject() {
+    const startPos = this.bytes.position();
+
+    const msg = `Trying to parse invalid object: ${JSON.stringify(startPos)})`;
+    if (this.throwOnInvalidObject) throw new Error(msg);
+    console.warn(msg);
+
+    const ref = this.parseIndirectObjectHeader();
+
+    console.warn(`Invalid object ref: ${ref}`);
+
+    this.skipWhitespaceAndComments();
+    const start = this.bytes.offset();
+
+    let failed = true;
+    while (!this.bytes.done()) {
+      if (this.matchKeyword(Keywords.endobj)) {
+        failed = false;
+      }
+      if (!failed) break;
+      this.bytes.next();
+    }
+
+    if (failed) throw new PDFInvalidObjectParsingError(startPos);
+
+    const end = this.bytes.offset() - Keywords.endobj.length;
+
+    const object = PDFInvalidObject.of(this.bytes.slice(start, end));
+    this.context.assign(ref, object);
+
+    return ref;
+  }
+
+  private async parseIndirectObjects(): Promise<void> {
+    this.skipWhitespaceAndComments();
+
+    while (!this.bytes.done() && IsDigit[this.bytes.peek()]) {
+      const initialOffset = this.bytes.offset();
+
+      try {
+        await this.parseIndirectObject();
+      } catch (e) {
+        // TODO: Add tracing/logging mechanism to track when this happens!
+        this.bytes.moveTo(initialOffset);
+        this.tryToParseInvalidIndirectObject();
+      }
+      this.skipWhitespaceAndComments();
+
+      // TODO: Can this be done only when needed, to avoid harming performance?
+      this.skipJibberish();
+
+      if (this.shouldWaitForTick()) await waitForTick();
+    }
+  }
+
+  private maybeParseCrossRefSection(): PDFCrossRefSection | void {
+    this.skipWhitespaceAndComments();
+    if (!this.matchKeyword(Keywords.xref)) return;
+    this.skipWhitespaceAndComments();
+
+    let objectNumber = -1;
+    const xref = PDFCrossRefSection.createEmpty();
+
+    while (!this.bytes.done() && IsDigit[this.bytes.peek()]) {
+      const firstInt = this.parseRawInt();
+      this.skipWhitespaceAndComments();
+
+      const secondInt = this.parseRawInt();
+      this.skipWhitespaceAndComments();
+
+      const byte = this.bytes.peek();
+      if (byte === CharCodes.n || byte === CharCodes.f) {
+        const ref = PDFRef.of(objectNumber, secondInt);
+        if (this.bytes.next() === CharCodes.n) {
+          xref.addEntry(ref, firstInt);
+        } else {
+          // this.context.delete(ref);
+          xref.addDeletedEntry(ref, firstInt);
+        }
+        objectNumber += 1;
+      } else {
+        objectNumber = firstInt;
+      }
+      this.skipWhitespaceAndComments();
+    }
+
+    return xref;
+  }
+
+  private maybeParseTrailerDict(): void {
+    this.skipWhitespaceAndComments();
+    if (!this.matchKeyword(Keywords.trailer)) return;
+    this.skipWhitespaceAndComments();
+
+    const dict = this.parseDict();
+
+    const { context } = this;
+    context.trailerInfo = {
+      Root: dict.get(PDFName.of('Root')) || context.trailerInfo.Root,
+      Encrypt: dict.get(PDFName.of('Encrypt')) || context.trailerInfo.Encrypt,
+      Info: dict.get(PDFName.of('Info')) || context.trailerInfo.Info,
+      ID: dict.get(PDFName.of('ID')) || context.trailerInfo.ID,
+    };
+  }
+
+  private maybeParseTrailer(): PDFTrailer | void {
+    this.skipWhitespaceAndComments();
+    if (!this.matchKeyword(Keywords.startxref)) return;
+    this.skipWhitespaceAndComments();
+
+    const offset = this.parseRawInt();
+    this.context.pdfFileDetails.prevStartXRef = offset;
+
+    this.skipWhitespace();
+    this.matchKeyword(Keywords.eof);
+    this.skipWhitespaceAndComments();
+    this.matchKeyword(Keywords.eof);
+    this.skipWhitespaceAndComments();
+
+    return PDFTrailer.forLastCrossRefSectionOffset(offset);
+  }
+
+  private async parseDocumentSection(): Promise<void> {
+    await this.parseIndirectObjects();
+    this.maybeParseCrossRefSection();
+    this.maybeParseTrailerDict();
+    this.maybeParseTrailer();
+
+    // TODO: Can this be done only when needed, to avoid harming performance?
+    this.skipJibberish();
+  }
+
+  /**
+   * This operation is not necessary for valid PDF files. But some invalid PDFs
+   * contain jibberish in between indirect objects. This method is designed to
+   * skip past that jibberish, should it exist, until it reaches the next
+   * indirect object header, an xref table section, or the file trailer.
+   */
+  private skipJibberish(): void {
+    this.skipWhitespaceAndComments();
+    while (!this.bytes.done()) {
+      const initialOffset = this.bytes.offset();
+      const byte = this.bytes.peek();
+      const isAlphaNumeric = byte >= CharCodes.Space && byte <= CharCodes.Tilde;
+      if (isAlphaNumeric) {
+        if (
+          this.matchKeyword(Keywords.xref) ||
+          this.matchKeyword(Keywords.trailer) ||
+          this.matchKeyword(Keywords.startxref) ||
+          this.matchIndirectObjectHeader()
+        ) {
+          this.bytes.moveTo(initialOffset);
+          break;
+        }
+      }
+      this.bytes.next();
+    }
+  }
+
+  /**
+   * Skips the binary comment following a PDF header. The specification
+   * defines this binary comment (section 7.5.2 File Header) as a sequence of 4
+   * or more bytes that are 128 or greater, and which are preceded by a "%".
+   *
+   * This would imply that to strip out this binary comment, we could check for
+   * a sequence of bytes starting with "%", and remove all subsequent bytes that
+   * are 128 or greater. This works for many documents that properly comply with
+   * the spec. But in the wild, there are PDFs that omit the leading "%", and
+   * include bytes that are less than 128 (e.g. 0 or 1). So in order to parse
+   * these headers correctly, we just throw out all bytes leading up to the
+   * first indirect object header.
+   */
+  private skipBinaryHeaderComment(): void {
+    this.skipWhitespaceAndComments();
+    try {
+      const initialOffset = this.bytes.offset();
+      this.parseIndirectObjectHeader();
+      this.bytes.moveTo(initialOffset);
+    } catch (e) {
+      this.bytes.next();
+      this.skipWhitespaceAndComments();
+    }
+  }
+}
+
+export default PDFParser;

package/src/core/parser/PDFXRefStreamParser.ts

@@ -0,0 +1,131 @@
+import { ReparseError } from 'src/core/errors';
+import PDFArray from 'src/core/objects/PDFArray';
+import PDFDict from 'src/core/objects/PDFDict';
+import PDFName from 'src/core/objects/PDFName';
+import PDFNumber from 'src/core/objects/PDFNumber';
+import PDFRawStream from 'src/core/objects/PDFRawStream';
+import PDFRef from 'src/core/objects/PDFRef';
+import ByteStream from 'src/core/parser/ByteStream';
+import PDFContext from 'src/core/PDFContext';
+
+export interface Entry {
+  ref: PDFRef;
+  offset: number;
+  deleted: boolean;
+  inObjectStream: boolean;
+}
+
+class PDFXRefStreamParser {
+  static forStream = (rawStream: PDFRawStream) =>
+    new PDFXRefStreamParser(rawStream);
+
+  private alreadyParsed: boolean;
+
+  private readonly dict: PDFDict;
+  private readonly context: PDFContext;
+  private readonly bytes: ByteStream;
+  private readonly subsections: {
+    firstObjectNumber: number;
+    length: number;
+  }[];
+  private readonly byteWidths: [number, number, number];
+
+  constructor(rawStream: PDFRawStream) {
+    this.alreadyParsed = false;
+
+    this.dict = rawStream.dict;
+    this.bytes = ByteStream.fromPDFRawStream(rawStream);
+    this.context = this.dict.context;
+    this.context.pdfFileDetails.useObjectStreams = true;
+
+    const Size = this.dict.lookup(PDFName.of('Size'), PDFNumber);
+
+    const Index = this.dict.lookup(PDFName.of('Index'));
+    if (Index instanceof PDFArray) {
+      this.subsections = [];
+      for (let idx = 0, len = Index.size(); idx < len; idx += 2) {
+        const firstObjectNumber = Index.lookup(idx + 0, PDFNumber).asNumber();
+        const length = Index.lookup(idx + 1, PDFNumber).asNumber();
+        this.subsections.push({ firstObjectNumber, length });
+      }
+    } else {
+      this.subsections = [{ firstObjectNumber: 0, length: Size.asNumber() }];
+    }
+
+    const W = this.dict.lookup(PDFName.of('W'), PDFArray);
+    this.byteWidths = [-1, -1, -1];
+    for (let idx = 0, len = W.size(); idx < len; idx++) {
+      this.byteWidths[idx] = W.lookup(idx, PDFNumber).asNumber();
+    }
+  }
+
+  parseIntoContext(): Entry[] {
+    if (this.alreadyParsed) {
+      throw new ReparseError('PDFXRefStreamParser', 'parseIntoContext');
+    }
+    this.alreadyParsed = true;
+
+    this.context.trailerInfo = {
+      Root: this.dict.get(PDFName.of('Root')),
+      Encrypt: this.dict.get(PDFName.of('Encrypt')),
+      Info: this.dict.get(PDFName.of('Info')),
+      ID: this.dict.get(PDFName.of('ID')),
+    };
+
+    const entries = this.parseEntries();
+
+    // for (let idx = 0, len = entries.length; idx < len; idx++) {
+    // const entry = entries[idx];
+    // if (entry.deleted) this.context.delete(entry.ref);
+    // }
+
+    return entries;
+  }
+
+  private parseEntries(): Entry[] {
+    const entries = [];
+    const [typeFieldWidth, offsetFieldWidth, genFieldWidth] = this.byteWidths;
+
+    for (
+      let subsectionIdx = 0, subsectionLen = this.subsections.length;
+      subsectionIdx < subsectionLen;
+      subsectionIdx++
+    ) {
+      const { firstObjectNumber, length } = this.subsections[subsectionIdx];
+
+      for (let objIdx = 0; objIdx < length; objIdx++) {
+        let type = 0;
+        for (let idx = 0, len = typeFieldWidth; idx < len; idx++) {
+          type = (type << 8) | this.bytes.next();
+        }
+
+        let offset = 0;
+        for (let idx = 0, len = offsetFieldWidth; idx < len; idx++) {
+          offset = (offset << 8) | this.bytes.next();
+        }
+
+        let generationNumber = 0;
+        for (let idx = 0, len = genFieldWidth; idx < len; idx++) {
+          generationNumber = (generationNumber << 8) | this.bytes.next();
+        }
+
+        // When the `type` field is absent, it defaults to 1
+        if (typeFieldWidth === 0) type = 1;
+
+        const objectNumber = firstObjectNumber + objIdx;
+        const entry = {
+          ref: PDFRef.of(objectNumber, generationNumber),
+          offset,
+          deleted: type === 0,
+          inObjectStream: type === 2,
+        };
+
+        entries.push(entry);
+      }
+    }
+
+    return entries;
+  }
+}
+
+export default PDFXRefStreamParser;

package/src/core/streams/Ascii85Stream.ts

@@ -0,0 +1,98 @@
+/*
+ * Copyright 2012 Mozilla Foundation
+ *
+ * The Ascii85Stream class contained in this file is a TypeScript port of the
+ * JavaScript Ascii85Stream class in Mozilla's pdf.js project, made available
+ * under the Apache 2.0 open source license.
+ */
+
+import DecodeStream from 'src/core/streams/DecodeStream';
+import { StreamType } from 'src/core/streams/Stream';
+
+const isSpace = (ch: number) =>
+  ch === 0x20 || ch === 0x09 || ch === 0x0d || ch === 0x0a;
+
+class Ascii85Stream extends DecodeStream {
+  private stream: StreamType;
+  private input: Uint8Array;
+
+  constructor(stream: StreamType, maybeLength?: number) {
+    super(maybeLength);
+
+    this.stream = stream;
+    this.input = new Uint8Array(5);
+
+    // Most streams increase in size when decoded, but Ascii85 streams
+    // typically shrink by ~20%.
+    if (maybeLength) {
+      maybeLength = 0.8 * maybeLength;
+    }
+  }
+
+  protected readBlock() {
+    const TILDA_CHAR = 0x7e; // '~'
+    const Z_LOWER_CHAR = 0x7a; // 'z'
+    const EOF = -1;
+
+    const stream = this.stream;
+
+    let c = stream.getByte();
+    while (isSpace(c)) {
+      c = stream.getByte();
+    }
+
+    if (c === EOF || c === TILDA_CHAR) {
+      this.eof = true;
+      return;
+    }
+
+    const bufferLength = this.bufferLength;
+    let buffer;
+    let i;
+
+    // special code for z
+    if (c === Z_LOWER_CHAR) {
+      buffer = this.ensureBuffer(bufferLength + 4);
+      for (i = 0; i < 4; ++i) {
+        buffer[bufferLength + i] = 0;
+      }
+      this.bufferLength += 4;
+    } else {
+      const input = this.input;
+      input[0] = c;
+      for (i = 1; i < 5; ++i) {
+        c = stream.getByte();
+        while (isSpace(c)) {
+          c = stream.getByte();
+        }
+
+        input[i] = c;
+
+        if (c === EOF || c === TILDA_CHAR) {
+          break;
+        }
+      }
+      buffer = this.ensureBuffer(bufferLength + i - 1);
+      this.bufferLength += i - 1;
+
+      // partial ending;
+      if (i < 5) {
+        for (; i < 5; ++i) {
+          input[i] = 0x21 + 84;
+        }
+        this.eof = true;
+      }
+      let t = 0;
+      for (i = 0; i < 5; ++i) {
+        t = t * 85 + (input[i] - 0x21);
+      }
+
+      for (i = 3; i >= 0; --i) {
+        buffer[bufferLength + i] = t & 0xff;
+        t >>= 8;
+      }
+    }
+  }
+}
+
+export default Ascii85Stream;

package/src/core/streams/AsciiHexStream.ts

@@ -0,0 +1,77 @@
+/*
+ * Copyright 2012 Mozilla Foundation
+ *
+ * The AsciiHexStream class contained in this file is a TypeScript port of the
+ * JavaScript AsciiHexStream class in Mozilla's pdf.js project, made available
+ * under the Apache 2.0 open source license.
+ */
+
+import DecodeStream from 'src/core/streams/DecodeStream';
+import { StreamType } from 'src/core/streams/Stream';
+
+class AsciiHexStream extends DecodeStream {
+  private stream: StreamType;
+  private firstDigit: number;
+
+  constructor(stream: StreamType, maybeLength?: number) {
+    super(maybeLength);
+
+    this.stream = stream;
+
+    this.firstDigit = -1;
+
+    // Most streams increase in size when decoded, but AsciiHex streams shrink
+    // by 50%.
+    if (maybeLength) {
+      maybeLength = 0.5 * maybeLength;
+    }
+  }
+
+  protected readBlock() {
+    const UPSTREAM_BLOCK_SIZE = 8000;
+    const bytes = this.stream.getBytes(UPSTREAM_BLOCK_SIZE);
+    if (!bytes.length) {
+      this.eof = true;
+      return;
+    }
+
+    const maxDecodeLength = (bytes.length + 1) >> 1;
+    const buffer = this.ensureBuffer(this.bufferLength + maxDecodeLength);
+    let bufferLength = this.bufferLength;
+
+    let firstDigit = this.firstDigit;
+    for (let i = 0, ii = bytes.length; i < ii; i++) {
+      const ch = bytes[i];
+      let digit;
+      if (ch >= 0x30 && ch <= 0x39) {
+        // '0'-'9'
+        digit = ch & 0x0f;
+      } else if ((ch >= 0x41 && ch <= 0x46) || (ch >= 0x61 && ch <= 0x66)) {
+        // 'A'-'Z', 'a'-'z'
+        digit = (ch & 0x0f) + 9;
+      } else if (ch === 0x3e) {
+        // '>'
+        this.eof = true;
+        break;
+      } else {
+        // probably whitespace
+        continue; // ignoring
+      }
+      if (firstDigit < 0) {
+        firstDigit = digit;
+      } else {
+        buffer[bufferLength++] = (firstDigit << 4) | digit;
+        firstDigit = -1;
+      }
+    }
+    if (firstDigit >= 0 && this.eof) {
+      // incomplete byte
+      buffer[bufferLength++] = firstDigit << 4;
+      firstDigit = -1;
+    }
+    this.firstDigit = firstDigit;
+    this.bufferLength = bufferLength;
+  }
+}
+
+export default AsciiHexStream;