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

package/src/core/streams/LZWStream.ts

@@ -1,157 +0,0 @@
-/*
- * Copyright 2012 Mozilla Foundation
- *
- * The LZWStream class contained in this file is a TypeScript port of the
- * JavaScript LZWStream 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 LZWStream extends DecodeStream {
-  private stream: StreamType;
-  private cachedData: number;
-  private bitsCached: number;
-  private lzwState?: {
-    earlyChange: 0 | 1;
-    codeLength: number;
-    nextCode: number;
-    dictionaryValues: Uint8Array;
-    dictionaryLengths: Uint16Array;
-    dictionaryPrevCodes: Uint16Array;
-    currentSequence: Uint8Array;
-    currentSequenceLength: number;
-    prevCode?: number | null;
-  };
-
-  constructor(stream: StreamType, maybeLength: number | undefined, earlyChange: 0 | 1) {
-    super(maybeLength);
-
-    this.stream = stream;
-    this.cachedData = 0;
-    this.bitsCached = 0;
-
-    const maxLzwDictionarySize = 4096;
-    const lzwState = {
-      earlyChange,
-      codeLength: 9,
-      nextCode: 258,
-      dictionaryValues: new Uint8Array(maxLzwDictionarySize),
-      dictionaryLengths: new Uint16Array(maxLzwDictionarySize),
-      dictionaryPrevCodes: new Uint16Array(maxLzwDictionarySize),
-      currentSequence: new Uint8Array(maxLzwDictionarySize),
-      currentSequenceLength: 0,
-    };
-    for (let i = 0; i < 256; ++i) {
-      lzwState.dictionaryValues[i] = i;
-      lzwState.dictionaryLengths[i] = 1;
-    }
-    this.lzwState = lzwState;
-  }
-
-  protected readBlock() {
-    const blockSize = 512;
-
-    let estimatedDecodedSize = blockSize * 2;
-    const decodedSizeDelta = blockSize;
-    let i;
-    let j;
-    let q;
-
-    const lzwState = this.lzwState;
-    if (!lzwState) {
-      return; // eof was found
-    }
-
-    const earlyChange = lzwState.earlyChange;
-    let nextCode = lzwState.nextCode;
-    const dictionaryValues = lzwState.dictionaryValues;
-    const dictionaryLengths = lzwState.dictionaryLengths;
-    const dictionaryPrevCodes = lzwState.dictionaryPrevCodes;
-    let codeLength = lzwState.codeLength;
-    let prevCode = lzwState.prevCode;
-    const currentSequence = lzwState.currentSequence;
-    let currentSequenceLength = lzwState.currentSequenceLength;
-
-    let decodedLength = 0;
-    let currentBufferLength = this.bufferLength;
-    let buffer = this.ensureBuffer(this.bufferLength + estimatedDecodedSize);
-
-    for (i = 0; i < blockSize; i++) {
-      const code = this.readBits(codeLength);
-      const hasPrev = currentSequenceLength > 0;
-      if (!code || code < 256) {
-        currentSequence[0] = code as number;
-        currentSequenceLength = 1;
-      } else if (code >= 258) {
-        if (code < nextCode) {
-          currentSequenceLength = dictionaryLengths[code];
-          for (j = currentSequenceLength - 1, q = code; j >= 0; j--) {
-            currentSequence[j] = dictionaryValues[q];
-            q = dictionaryPrevCodes[q];
-          }
-        } else {
-          currentSequence[currentSequenceLength++] = currentSequence[0];
-        }
-      } else if (code === 256) {
-        codeLength = 9;
-        nextCode = 258;
-        currentSequenceLength = 0;
-        continue;
-      } else {
-        this.eof = true;
-        delete this.lzwState;
-        break;
-      }
-
-      if (hasPrev) {
-        dictionaryPrevCodes[nextCode] = prevCode as number;
-        dictionaryLengths[nextCode] = dictionaryLengths[prevCode as number] + 1;
-        dictionaryValues[nextCode] = currentSequence[0];
-        nextCode++;
-        codeLength =
-          (nextCode + earlyChange) & (nextCode + earlyChange - 1)
-            ? codeLength
-            : Math.min(Math.log(nextCode + earlyChange) / 0.6931471805599453 + 1, 12) | 0;
-      }
-      prevCode = code;
-
-      decodedLength += currentSequenceLength;
-      if (estimatedDecodedSize < decodedLength) {
-        do {
-          estimatedDecodedSize += decodedSizeDelta;
-        } while (estimatedDecodedSize < decodedLength);
-        buffer = this.ensureBuffer(this.bufferLength + estimatedDecodedSize);
-      }
-      for (j = 0; j < currentSequenceLength; j++) {
-        buffer[currentBufferLength++] = currentSequence[j];
-      }
-    }
-    lzwState.nextCode = nextCode;
-    lzwState.codeLength = codeLength;
-    lzwState.prevCode = prevCode;
-    lzwState.currentSequenceLength = currentSequenceLength;
-
-    this.bufferLength = currentBufferLength;
-  }
-
-  private readBits(n: number) {
-    let bitsCached = this.bitsCached;
-    let cachedData = this.cachedData;
-    while (bitsCached < n) {
-      const c = this.stream.getByte();
-      if (c === -1) {
-        this.eof = true;
-        return null;
-      }
-      cachedData = (cachedData << 8) | c;
-      bitsCached += 8;
-    }
-    this.bitsCached = bitsCached -= n;
-    this.cachedData = cachedData;
-    return (cachedData >>> bitsCached) & ((1 << n) - 1);
-  }
-}
-
-export default LZWStream;

package/src/core/streams/RunLengthStream.ts

@@ -1,55 +0,0 @@
-/*
- * Copyright 2012 Mozilla Foundation
- *
- * The RunLengthStream class contained in this file is a TypeScript port of the
- * JavaScript RunLengthStream 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 RunLengthStream extends DecodeStream {
-  private stream: StreamType;
-
-  constructor(stream: StreamType, maybeLength?: number) {
-    super(maybeLength);
-    this.stream = stream;
-  }
-
-  protected readBlock() {
-    // The repeatHeader has following format. The first byte defines type of run
-    // and amount of bytes to repeat/copy: n = 0 through 127 - copy next n bytes
-    // (in addition to the second byte from the header), n = 129 through 255 -
-    // duplicate the second byte from the header (257 - n) times, n = 128 - end.
-    const repeatHeader = this.stream.getBytes(2);
-    if (!repeatHeader || repeatHeader.length < 2 || repeatHeader[0] === 128) {
-      this.eof = true;
-      return;
-    }
-
-    let buffer;
-    let bufferLength = this.bufferLength;
-    let n = repeatHeader[0];
-    if (n < 128) {
-      // copy n bytes
-      buffer = this.ensureBuffer(bufferLength + n + 1);
-      buffer[bufferLength++] = repeatHeader[1];
-      if (n > 0) {
-        const source = this.stream.getBytes(n);
-        buffer.set(source, bufferLength);
-        bufferLength += n;
-      }
-    } else {
-      n = 257 - n;
-      const b = repeatHeader[1];
-      buffer = this.ensureBuffer(bufferLength + n + 1);
-      for (let i = 0; i < n; i++) {
-        buffer[bufferLength++] = b;
-      }
-    }
-    this.bufferLength = bufferLength;
-  }
-}
-
-export default RunLengthStream;

package/src/core/streams/Stream.ts

@@ -1,126 +0,0 @@
-/*
- * Copyright 2012 Mozilla Foundation
- *
- * The Stream class contained in this file is a TypeScript port of the
- * JavaScript Stream class in Mozilla's pdf.js project, made available
- * under the Apache 2.0 open source license.
- */
-
-export interface StreamType {
-  isEmpty: boolean;
-  getByte(): number;
-  getUint16(): number;
-  getInt32(): number;
-  getBytes(length: number, forceClamped?: boolean): Uint8Array | Uint8ClampedArray;
-  peekByte(): number;
-  peekBytes(length: number, forceClamped?: boolean): Uint8Array | Uint8ClampedArray;
-  skip(n: number): void;
-  reset(): void;
-  makeSubStream(start: number, length: number): StreamType;
-  decode(): Uint8Array;
-}
-
-class Stream implements StreamType {
-  private bytes: Uint8Array;
-  private start: number;
-  private pos: number;
-  private end: number;
-
-  constructor(buffer: Uint8Array, start?: number, length?: number) {
-    this.bytes = buffer;
-    this.start = start || 0;
-    this.pos = this.start;
-    this.end = !!start && !!length ? start + length : this.bytes.length;
-  }
-
-  get length() {
-    return this.end - this.start;
-  }
-
-  get isEmpty() {
-    return this.length === 0;
-  }
-
-  getByte() {
-    if (this.pos >= this.end) {
-      return -1;
-    }
-    return this.bytes[this.pos++];
-  }
-
-  getUint16() {
-    const b0 = this.getByte();
-    const b1 = this.getByte();
-    if (b0 === -1 || b1 === -1) {
-      return -1;
-    }
-    return (b0 << 8) + b1;
-  }
-
-  getInt32() {
-    const b0 = this.getByte();
-    const b1 = this.getByte();
-    const b2 = this.getByte();
-    const b3 = this.getByte();
-    return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
-  }
-
-  // Returns subarray of original buffer, should only be read.
-  getBytes(length: number, forceClamped = false) {
-    const bytes = this.bytes;
-    const pos = this.pos;
-    const strEnd = this.end;
-
-    if (!length) {
-      const subarray = bytes.subarray(pos, strEnd);
-      // `this.bytes` is always a `Uint8Array` here.
-      return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
-    } else {
-      let end = pos + length;
-      if (end > strEnd) {
-        end = strEnd;
-      }
-      this.pos = end;
-      const subarray = bytes.subarray(pos, end);
-      // `this.bytes` is always a `Uint8Array` here.
-      return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
-    }
-  }
-
-  peekByte() {
-    const peekedByte = this.getByte();
-    this.pos--;
-    return peekedByte;
-  }
-
-  peekBytes(length: number, forceClamped = false) {
-    const bytes = this.getBytes(length, forceClamped);
-    this.pos -= bytes.length;
-    return bytes;
-  }
-
-  skip(n: number) {
-    if (!n) {
-      n = 1;
-    }
-    this.pos += n;
-  }
-
-  reset() {
-    this.pos = this.start;
-  }
-
-  moveStart() {
-    this.start = this.pos;
-  }
-
-  makeSubStream(start: number, length: number) {
-    return new Stream(this.bytes, start, length);
-  }
-
-  decode(): Uint8Array {
-    return this.bytes;
-  }
-}
-
-export default Stream;

package/src/core/streams/decode.ts

@@ -1,70 +0,0 @@
-import { UnexpectedObjectTypeError, UnsupportedEncodingError } from '../errors';
-import PDFArray from '../objects/PDFArray';
-import PDFDict from '../objects/PDFDict';
-import PDFName from '../objects/PDFName';
-import PDFNull from '../objects/PDFNull';
-import PDFNumber from '../objects/PDFNumber';
-import PDFRawStream from '../objects/PDFRawStream';
-import Ascii85Stream from './Ascii85Stream';
-import AsciiHexStream from './AsciiHexStream';
-import FlateStream from './FlateStream';
-import LZWStream from './LZWStream';
-import RunLengthStream from './RunLengthStream';
-import Stream, { StreamType } from './Stream';
-
-const decodeStream = (
-  stream: StreamType,
-  encoding: PDFName,
-  params: undefined | typeof PDFNull | PDFDict,
-) => {
-  if (encoding === PDFName.of('FlateDecode')) {
-    return new FlateStream(stream);
-  }
-  if (encoding === PDFName.of('LZWDecode')) {
-    let earlyChange = 1;
-    if (params instanceof PDFDict) {
-      const EarlyChange = params.lookup(PDFName.of('EarlyChange'));
-      if (EarlyChange instanceof PDFNumber) {
-        earlyChange = EarlyChange.asNumber();
-      }
-    }
-    return new LZWStream(stream, undefined, earlyChange as 0 | 1);
-  }
-  if (encoding === PDFName.of('ASCII85Decode')) {
-    return new Ascii85Stream(stream);
-  }
-  if (encoding === PDFName.of('ASCIIHexDecode')) {
-    return new AsciiHexStream(stream);
-  }
-  if (encoding === PDFName.of('RunLengthDecode')) {
-    return new RunLengthStream(stream);
-  }
-  throw new UnsupportedEncodingError(encoding.asString());
-};
-
-export const decodePDFRawStream = ({ dict, contents, transform }: PDFRawStream) => {
-  let stream: StreamType = new Stream(contents);
-
-  if (transform) {
-    stream = transform.createStream(stream, contents.length);
-  }
-
-  const Filter = dict.lookup(PDFName.of('Filter'));
-  const DecodeParms = dict.lookup(PDFName.of('DecodeParms'));
-
-  if (Filter instanceof PDFName) {
-    stream = decodeStream(stream, Filter, DecodeParms as PDFDict | typeof PDFNull | undefined);
-  } else if (Filter instanceof PDFArray) {
-    for (let idx = 0, len = Filter.size(); idx < len; idx++) {
-      stream = decodeStream(
-        stream,
-        Filter.lookup(idx, PDFName),
-        DecodeParms && (DecodeParms as PDFArray).lookupMaybe(idx, PDFDict),
-      );
-    }
-  } else if (Filter) {
-    throw new UnexpectedObjectTypeError([PDFName, PDFArray], Filter);
-  }
-
-  return stream;
-};

package/src/core/structures/PDFCatalog.ts

@@ -1,81 +0,0 @@
-import PDFDict, { DictMap } from '../objects/PDFDict';
-import PDFName from '../objects/PDFName';
-import PDFRef from '../objects/PDFRef';
-import PDFContext from '../PDFContext';
-import PDFPageTree from './PDFPageTree';
-import { PDFAcroForm } from '../acroform';
-import ViewerPreferences from '../interactive/ViewerPreferences';
-
-class PDFCatalog extends PDFDict {
-  static withContextAndPages = (context: PDFContext, pages: PDFPageTree | PDFRef) => {
-    const dict = new Map();
-    dict.set(PDFName.of('Type'), PDFName.of('Catalog'));
-    dict.set(PDFName.of('Pages'), pages);
-    return new PDFCatalog(dict, context);
-  };
-
-  static fromMapWithContext = (map: DictMap, context: PDFContext) => new PDFCatalog(map, context);
-
-  Pages(): PDFPageTree {
-    return this.lookup(PDFName.of('Pages'), PDFDict) as PDFPageTree;
-  }
-
-  AcroForm(): PDFDict | undefined {
-    return this.lookupMaybe(PDFName.of('AcroForm'), PDFDict);
-  }
-
-  getAcroForm(): PDFAcroForm | undefined {
-    const dict = this.AcroForm();
-    if (!dict) return undefined;
-    return PDFAcroForm.fromDict(dict);
-  }
-
-  getOrCreateAcroForm(): PDFAcroForm {
-    let acroForm = this.getAcroForm();
-    if (!acroForm) {
-      acroForm = PDFAcroForm.create(this.context);
-      const acroFormRef = this.context.register(acroForm.dict);
-      this.set(PDFName.of('AcroForm'), acroFormRef);
-    }
-    return acroForm;
-  }
-
-  ViewerPreferences(): PDFDict | undefined {
-    return this.lookupMaybe(PDFName.of('ViewerPreferences'), PDFDict);
-  }
-
-  getViewerPreferences(): ViewerPreferences | undefined {
-    const dict = this.ViewerPreferences();
-    if (!dict) return undefined;
-    return ViewerPreferences.fromDict(dict);
-  }
-
-  getOrCreateViewerPreferences(): ViewerPreferences {
-    let viewerPrefs = this.getViewerPreferences();
-    if (!viewerPrefs) {
-      viewerPrefs = ViewerPreferences.create(this.context);
-      const viewerPrefsRef = this.context.register(viewerPrefs.dict);
-      this.set(PDFName.of('ViewerPreferences'), viewerPrefsRef);
-    }
-    return viewerPrefs;
-  }
-
-  /**
-   * Inserts the given ref as a leaf node of this catalog's page tree at the
-   * specified index (zero-based). Also increments the `Count` of each node in
-   * the page tree hierarchy to accomodate the new page.
-   *
-   * Returns the ref of the PDFPageTree node into which `leafRef` was inserted.
-   */
-  insertLeafNode(leafRef: PDFRef, index: number): PDFRef {
-    const pagesRef = this.get(PDFName.of('Pages')) as PDFRef;
-    const maybeParentRef = this.Pages().insertLeafNode(leafRef, index);
-    return maybeParentRef || pagesRef;
-  }
-
-  removeLeafNode(index: number): void {
-    this.Pages().removeLeafNode(index);
-  }
-}
-
-export default PDFCatalog;

package/src/core/structures/PDFContentStream.ts

@@ -1,58 +0,0 @@
-import PDFDict from '../objects/PDFDict';
-import PDFOperator from '../operators/PDFOperator';
-import PDFContext from '../PDFContext';
-import PDFFlateStream from './PDFFlateStream';
-import CharCodes from '../syntax/CharCodes';
-
-class PDFContentStream extends PDFFlateStream {
-  static of = (dict: PDFDict, operators: PDFOperator[], encode = true) =>
-    new PDFContentStream(dict, operators, encode);
-
-  private readonly operators: PDFOperator[];
-
-  private constructor(dict: PDFDict, operators: PDFOperator[], encode = true) {
-    super(dict, encode);
-    this.operators = operators;
-  }
-
-  push(...operators: PDFOperator[]): void {
-    this.operators.push(...operators);
-  }
-
-  clone(context?: PDFContext): PDFContentStream {
-    const operators = Array(this.operators.length);
-    for (let idx = 0, len = this.operators.length; idx < len; idx++) {
-      operators[idx] = this.operators[idx].clone(context);
-    }
-    const { dict, encode } = this;
-    return PDFContentStream.of(dict.clone(context), operators, encode);
-  }
-
-  getContentsString(): string {
-    let value = '';
-    for (let idx = 0, len = this.operators.length; idx < len; idx++) {
-      value += `${this.operators[idx]}\n`;
-    }
-    return value;
-  }
-
-  getUnencodedContents(): Uint8Array {
-    const buffer = new Uint8Array(this.getUnencodedContentsSize());
-    let offset = 0;
-    for (let idx = 0, len = this.operators.length; idx < len; idx++) {
-      offset += this.operators[idx].copyBytesInto(buffer, offset);
-      buffer[offset++] = CharCodes.Newline;
-    }
-    return buffer;
-  }
-
-  getUnencodedContentsSize(): number {
-    let size = 0;
-    for (let idx = 0, len = this.operators.length; idx < len; idx++) {
-      size += this.operators[idx].sizeInBytes() + 1;
-    }
-    return size;
-  }
-}
-
-export default PDFContentStream;