@adnsistemas/pdf-lib 1.18.0

package/src/core/streams/LZWStream.ts

@@ -0,0 +1,164 @@
+/*
+ * 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 'src/core/streams/DecodeStream';
+import { StreamType } from 'src/core/streams/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

@@ -0,0 +1,55 @@
+/*
+ * 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 'src/core/streams/DecodeStream';
+import { StreamType } from 'src/core/streams/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

@@ -0,0 +1,132 @@
+/*
+ * 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

@@ -0,0 +1,73 @@
+import {
+  UnexpectedObjectTypeError,
+  UnsupportedEncodingError,
+} 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 PDFNull from 'src/core/objects/PDFNull';
+import PDFNumber from 'src/core/objects/PDFNumber';
+import PDFRawStream from 'src/core/objects/PDFRawStream';
+import Ascii85Stream from 'src/core/streams/Ascii85Stream';
+import AsciiHexStream from 'src/core/streams/AsciiHexStream';
+import FlateStream from 'src/core/streams/FlateStream';
+import LZWStream from 'src/core/streams/LZWStream';
+import RunLengthStream from 'src/core/streams/RunLengthStream';
+import Stream, { StreamType } from 'src/core/streams/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 }: PDFRawStream) => {
+  let stream: StreamType = new Stream(contents);
+
+  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

@@ -0,0 +1,85 @@
+import PDFDict, { DictMap } from 'src/core/objects/PDFDict';
+import PDFName from 'src/core/objects/PDFName';
+import PDFRef from 'src/core/objects/PDFRef';
+import PDFContext from 'src/core/PDFContext';
+import PDFPageTree from 'src/core/structures/PDFPageTree';
+import { PDFAcroForm } from 'src/core/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

@@ -0,0 +1,58 @@
+import PDFDict from 'src/core/objects/PDFDict';
+import PDFOperator from 'src/core/operators/PDFOperator';
+import PDFContext from 'src/core/PDFContext';
+import PDFFlateStream from 'src/core/structures/PDFFlateStream';
+import CharCodes from 'src/core/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 = new 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;