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

package/src/core/parser/PDFParser.ts

@@ -1,363 +0,0 @@
-import PDFCrossRefSection from '../document/PDFCrossRefSection';
-import PDFHeader from '../document/PDFHeader';
-import PDFTrailer from '../document/PDFTrailer';
-import {
-  MissingKeywordError,
-  MissingPDFHeaderError,
-  PDFInvalidObjectParsingError,
-  ReparseError,
-  StalledParserError,
-} from '../errors';
-import PDFDict from '../objects/PDFDict';
-import PDFInvalidObject from '../objects/PDFInvalidObject';
-import PDFName from '../objects/PDFName';
-import PDFObject from '../objects/PDFObject';
-import PDFRawStream from '../objects/PDFRawStream';
-import PDFRef from '../objects/PDFRef';
-import ByteStream from './ByteStream';
-import PDFObjectParser from './PDFObjectParser';
-import PDFObjectStreamParser from './PDFObjectStreamParser';
-import PDFXRefStreamParser from './PDFXRefStreamParser';
-import PDFContext from '../PDFContext';
-import CharCodes from '../syntax/CharCodes';
-import { Keywords } from '../syntax/Keywords';
-import { IsDigit } from '../syntax/Numeric';
-import { waitForTick } from '../../utils';
-import { CipherTransformFactory } from '../crypto';
-
-class PDFParser extends PDFObjectParser {
-  static forBytesWithOptions = (
-    pdfBytes: Uint8Array,
-    objectsPerTick?: number,
-    throwOnInvalidObject?: boolean,
-    capNumbers?: boolean,
-    cryptoFactory?: CipherTransformFactory,
-  ) => new PDFParser(pdfBytes, objectsPerTick, throwOnInvalidObject, capNumbers, cryptoFactory);
-
-  private readonly objectsPerTick: number;
-  private readonly throwOnInvalidObject: boolean;
-  private alreadyParsed = false;
-  private parsedObjects = 0;
-
-  constructor(
-    pdfBytes: Uint8Array,
-    objectsPerTick = Infinity,
-    throwOnInvalidObject = false,
-    capNumbers = false,
-    cryptoFactory?: CipherTransformFactory,
-  ) {
-    super(ByteStream.of(pdfBytes), PDFContext.create(), capNumbers, cryptoFactory);
-    this.objectsPerTick = objectsPerTick;
-    this.throwOnInvalidObject = throwOnInvalidObject;
-    this.context.isDecrypted = !!cryptoFactory?.encryptionKey;
-  }
-
-  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 {
-      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(ref);
-
-    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 {
-        // 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.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 {
-      this.bytes.next();
-      this.skipWhitespaceAndComments();
-    }
-  }
-}
-
-export default PDFParser;

package/src/core/parser/PDFXRefStreamParser.ts

@@ -1,129 +0,0 @@
-import { ReparseError } from '../errors';
-import PDFArray from '../objects/PDFArray';
-import PDFDict from '../objects/PDFDict';
-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 PDFContext from '../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;
-
-    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

@@ -1,97 +0,0 @@
-/*
- * 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 './DecodeStream';
-import { StreamType } from './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

@@ -1,77 +0,0 @@
-/*
- * 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 './DecodeStream';
-import { StreamType } from './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;