pdfjs-dist 2.0.943 → 2.4.456

package/lib/core/stream.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2018 Mozilla Foundation
+ * Copyright 2020 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,18 +19,18 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.LZWStream = exports.StringStream = exports.StreamsSequenceStream = exports.Stream = exports.RunLengthStream = exports.PredictorStream = exports.NullStream = exports.FlateStream = exports.DecodeStream = exports.DecryptStream = exports.AsciiHexStream = exports.Ascii85Stream = undefined;
+exports.LZWStream = exports.StringStream = exports.StreamsSequenceStream = exports.Stream = exports.RunLengthStream = exports.PredictorStream = exports.NullStream = exports.FlateStream = exports.DecodeStream = exports.DecryptStream = exports.AsciiHexStream = exports.Ascii85Stream = void 0;
 
-var _util = require('../shared/util');
+var _util = require("../shared/util.js");
 
-var _primitives = require('./primitives');
+var _primitives = require("./primitives.js");
 
-function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } else { return Array.from(arr); } }
+var _core_utils = require("./core_utils.js");
 
 var Stream = function StreamClosure() {
   function Stream(arrayBuffer, start, length, dict) {
@@ -40,25 +40,31 @@ var Stream = function StreamClosure() {
     this.end = start + length || this.bytes.length;
     this.dict = dict;
   }
+
   Stream.prototype = {
     get length() {
       return this.end - this.start;
     },
+
     get isEmpty() {
       return this.length === 0;
     },
+
     getByte: function Stream_getByte() {
       if (this.pos >= this.end) {
         return -1;
       }
+
       return this.bytes[this.pos++];
     },
     getUint16: function Stream_getUint16() {
       var b0 = this.getByte();
       var b1 = this.getByte();
+
       if (b0 === -1 || b1 === -1) {
         return -1;
       }
+
       return (b0 << 8) + b1;
     },
     getInt32: function Stream_getInt32() {
@@ -68,42 +74,61 @@ var Stream = function StreamClosure() {
       var b3 = this.getByte();
       return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
     },
-    getBytes: function getBytes(length) {
-      var forceClamped = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
 
+    getBytes(length, forceClamped = false) {
       var bytes = this.bytes;
       var pos = this.pos;
       var strEnd = this.end;
+
       if (!length) {
-        var _subarray = bytes.subarray(pos, strEnd);
-        return forceClamped ? new Uint8ClampedArray(_subarray) : _subarray;
+        const subarray = bytes.subarray(pos, strEnd);
+        return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
       }
+
       var end = pos + length;
+
       if (end > strEnd) {
         end = strEnd;
       }
+
       this.pos = end;
-      var subarray = bytes.subarray(pos, end);
+      const subarray = bytes.subarray(pos, end);
       return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
     },
 
     peekByte: function Stream_peekByte() {
       var peekedByte = this.getByte();
-      this.pos--;
+
+      if (peekedByte !== -1) {
+        this.pos--;
+      }
+
       return peekedByte;
     },
-    peekBytes: function peekBytes(length) {
-      var forceClamped = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
 
+    peekBytes(length, forceClamped = false) {
       var bytes = this.getBytes(length, forceClamped);
       this.pos -= bytes.length;
       return bytes;
     },
 
+    getByteRange(begin, end) {
+      if (begin < 0) {
+        begin = 0;
+      }
+
+      if (end > this.end) {
+        end = this.end;
+      }
+
+      return this.bytes.subarray(begin, end);
+    },
+
     skip: function Stream_skip(n) {
       if (!n) {
         n = 1;
       }
+
       this.pos += n;
     },
     reset: function Stream_reset() {
@@ -118,16 +143,24 @@ var Stream = function StreamClosure() {
   };
   return Stream;
 }();
+
+exports.Stream = Stream;
+
 var StringStream = function StringStreamClosure() {
   function StringStream(str) {
-    var bytes = (0, _util.stringToBytes)(str);
+    const bytes = (0, _util.stringToBytes)(str);
     Stream.call(this, bytes);
   }
+
   StringStream.prototype = Stream.prototype;
   return StringStream;
 }();
+
+exports.StringStream = StringStream;
+
 var DecodeStream = function DecodeStreamClosure() {
   var emptyBuffer = new Uint8Array(0);
+
   function DecodeStream(maybeMinBufferLength) {
     this._rawMinBufferLength = maybeMinBufferLength || 0;
     this.pos = 0;
@@ -135,48 +168,61 @@ var DecodeStream = function DecodeStreamClosure() {
     this.eof = false;
     this.buffer = emptyBuffer;
     this.minBufferLength = 512;
+
     if (maybeMinBufferLength) {
       while (this.minBufferLength < maybeMinBufferLength) {
         this.minBufferLength *= 2;
       }
     }
   }
+
   DecodeStream.prototype = {
     get isEmpty() {
       while (!this.eof && this.bufferLength === 0) {
         this.readBlock();
       }
+
       return this.bufferLength === 0;
     },
+
     ensureBuffer: function DecodeStream_ensureBuffer(requested) {
       var buffer = this.buffer;
+
       if (requested <= buffer.byteLength) {
         return buffer;
       }
+
       var size = this.minBufferLength;
+
       while (size < requested) {
         size *= 2;
       }
+
       var buffer2 = new Uint8Array(size);
       buffer2.set(buffer);
       return this.buffer = buffer2;
     },
     getByte: function DecodeStream_getByte() {
       var pos = this.pos;
+
       while (this.bufferLength <= pos) {
         if (this.eof) {
           return -1;
         }
+
         this.readBlock();
       }
+
       return this.buffer[this.pos++];
     },
     getUint16: function DecodeStream_getUint16() {
       var b0 = this.getByte();
       var b1 = this.getByte();
+
       if (b0 === -1 || b1 === -1) {
         return -1;
       }
+
       return (b0 << 8) + b1;
     },
     getInt32: function DecodeStream_getInt32() {
@@ -186,18 +232,21 @@ var DecodeStream = function DecodeStreamClosure() {
       var b3 = this.getByte();
       return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
     },
-    getBytes: function getBytes(length) {
-      var forceClamped = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
 
+    getBytes(length, forceClamped = false) {
       var end,
           pos = this.pos;
+
       if (length) {
         this.ensureBuffer(pos + length);
         end = pos + length;
+
         while (!this.eof && this.bufferLength < end) {
           this.readBlock();
         }
+
         var bufEnd = this.bufferLength;
+
         if (end > bufEnd) {
           end = bufEnd;
         }
@@ -205,21 +254,26 @@ var DecodeStream = function DecodeStreamClosure() {
         while (!this.eof) {
           this.readBlock();
         }
+
         end = this.bufferLength;
       }
+
       this.pos = end;
-      var subarray = this.buffer.subarray(pos, end);
+      const subarray = this.buffer.subarray(pos, end);
       return forceClamped && !(subarray instanceof Uint8ClampedArray) ? new Uint8ClampedArray(subarray) : subarray;
     },
 
     peekByte: function DecodeStream_peekByte() {
       var peekedByte = this.getByte();
-      this.pos--;
+
+      if (peekedByte !== -1) {
+        this.pos--;
+      }
+
       return peekedByte;
     },
-    peekBytes: function peekBytes(length) {
-      var forceClamped = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
 
+    peekBytes(length, forceClamped = false) {
       var bytes = this.getBytes(length, forceClamped);
       this.pos -= bytes.length;
       return bytes;
@@ -227,15 +281,23 @@ var DecodeStream = function DecodeStreamClosure() {
 
     makeSubStream: function DecodeStream_makeSubStream(start, length, dict) {
       var end = start + length;
+
       while (this.bufferLength <= end && !this.eof) {
         this.readBlock();
       }
+
       return new Stream(this.buffer, start, length, dict);
     },
+
+    getByteRange(begin, end) {
+      (0, _util.unreachable)("Should not call DecodeStream.getByteRange");
+    },
+
     skip: function DecodeStream_skip(n) {
       if (!n) {
         n = 1;
       }
+
       this.pos += n;
     },
     reset: function DecodeStream_reset() {
@@ -245,32 +307,43 @@ var DecodeStream = function DecodeStreamClosure() {
       if (this.str && this.str.getBaseStreams) {
         return this.str.getBaseStreams();
       }
+
       return [];
     }
   };
   return DecodeStream;
 }();
+
+exports.DecodeStream = DecodeStream;
+
 var StreamsSequenceStream = function StreamsSequenceStreamClosure() {
   function StreamsSequenceStream(streams) {
     this.streams = streams;
-    var maybeLength = 0;
-    for (var i = 0, ii = streams.length; i < ii; i++) {
-      var stream = streams[i];
+    let maybeLength = 0;
+
+    for (let i = 0, ii = streams.length; i < ii; i++) {
+      const stream = streams[i];
+
       if (stream instanceof DecodeStream) {
         maybeLength += stream._rawMinBufferLength;
       } else {
         maybeLength += stream.length;
       }
     }
+
     DecodeStream.call(this, maybeLength);
   }
+
   StreamsSequenceStream.prototype = Object.create(DecodeStream.prototype);
+
   StreamsSequenceStream.prototype.readBlock = function streamSequenceStreamReadBlock() {
     var streams = this.streams;
+
     if (streams.length === 0) {
       this.eof = true;
       return;
     }
+
     var stream = streams.shift();
     var chunk = stream.getBytes();
     var bufferLength = this.bufferLength;
@@ -279,63 +352,83 @@ var StreamsSequenceStream = function StreamsSequenceStreamClosure() {
     buffer.set(chunk, bufferLength);
     this.bufferLength = newLength;
   };
+
   StreamsSequenceStream.prototype.getBaseStreams = function StreamsSequenceStream_getBaseStreams() {
     var baseStreams = [];
+
     for (var i = 0, ii = this.streams.length; i < ii; i++) {
       var stream = this.streams[i];
+
       if (stream.getBaseStreams) {
-        baseStreams.push.apply(baseStreams, _toConsumableArray(stream.getBaseStreams()));
+        baseStreams.push(...stream.getBaseStreams());
       }
     }
+
     return baseStreams;
   };
+
   return StreamsSequenceStream;
 }();
+
+exports.StreamsSequenceStream = StreamsSequenceStream;
+
 var FlateStream = function FlateStreamClosure() {
   var codeLenCodeMap = new Int32Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
   var lengthDecode = new Int32Array([0x00003, 0x00004, 0x00005, 0x00006, 0x00007, 0x00008, 0x00009, 0x0000a, 0x1000b, 0x1000d, 0x1000f, 0x10011, 0x20013, 0x20017, 0x2001b, 0x2001f, 0x30023, 0x3002b, 0x30033, 0x3003b, 0x40043, 0x40053, 0x40063, 0x40073, 0x50083, 0x500a3, 0x500c3, 0x500e3, 0x00102, 0x00102, 0x00102]);
   var distDecode = new Int32Array([0x00001, 0x00002, 0x00003, 0x00004, 0x10005, 0x10007, 0x20009, 0x2000d, 0x30011, 0x30019, 0x40021, 0x40031, 0x50041, 0x50061, 0x60081, 0x600c1, 0x70101, 0x70181, 0x80201, 0x80301, 0x90401, 0x90601, 0xa0801, 0xa0c01, 0xb1001, 0xb1801, 0xc2001, 0xc3001, 0xd4001, 0xd6001]);
   var fixedLitCodeTab = [new Int32Array([0x70100, 0x80050, 0x80010, 0x80118, 0x70110, 0x80070, 0x80030, 0x900c0, 0x70108, 0x80060, 0x80020, 0x900a0, 0x80000, 0x80080, 0x80040, 0x900e0, 0x70104, 0x80058, 0x80018, 0x90090, 0x70114, 0x80078, 0x80038, 0x900d0, 0x7010c, 0x80068, 0x80028, 0x900b0, 0x80008, 0x80088, 0x80048, 0x900f0, 0x70102, 0x80054, 0x80014, 0x8011c, 0x70112, 0x80074, 0x80034, 0x900c8, 0x7010a, 0x80064, 0x80024, 0x900a8, 0x80004, 0x80084, 0x80044, 0x900e8, 0x70106, 0x8005c, 0x8001c, 0x90098, 0x70116, 0x8007c, 0x8003c, 0x900d8, 0x7010e, 0x8006c, 0x8002c, 0x900b8, 0x8000c, 0x8008c, 0x8004c, 0x900f8, 0x70101, 0x80052, 0x80012, 0x8011a, 0x70111, 0x80072, 0x80032, 0x900c4, 0x70109, 0x80062, 0x80022, 0x900a4, 0x80002, 0x80082, 0x80042, 0x900e4, 0x70105, 0x8005a, 0x8001a, 0x90094, 0x70115, 0x8007a, 0x8003a, 0x900d4, 0x7010d, 0x8006a, 0x8002a, 0x900b4, 0x8000a, 0x8008a, 0x8004a, 0x900f4, 0x70103, 0x80056, 0x80016, 0x8011e, 0x70113, 0x80076, 0x80036, 0x900cc, 0x7010b, 0x80066, 0x80026, 0x900ac, 0x80006, 0x80086, 0x80046, 0x900ec, 0x70107, 0x8005e, 0x8001e, 0x9009c, 0x70117, 0x8007e, 0x8003e, 0x900dc, 0x7010f, 0x8006e, 0x8002e, 0x900bc, 0x8000e, 0x8008e, 0x8004e, 0x900fc, 0x70100, 0x80051, 0x80011, 0x80119, 0x70110, 0x80071, 0x80031, 0x900c2, 0x70108, 0x80061, 0x80021, 0x900a2, 0x80001, 0x80081, 0x80041, 0x900e2, 0x70104, 0x80059, 0x80019, 0x90092, 0x70114, 0x80079, 0x80039, 0x900d2, 0x7010c, 0x80069, 0x80029, 0x900b2, 0x80009, 0x80089, 0x80049, 0x900f2, 0x70102, 0x80055, 0x80015, 0x8011d, 0x70112, 0x80075, 0x80035, 0x900ca, 0x7010a, 0x80065, 0x80025, 0x900aa, 0x80005, 0x80085, 0x80045, 0x900ea, 0x70106, 0x8005d, 0x8001d, 0x9009a, 0x70116, 0x8007d, 0x8003d, 0x900da, 0x7010e, 0x8006d, 0x8002d, 0x900ba, 0x8000d, 0x8008d, 0x8004d, 0x900fa, 0x70101, 0x80053, 0x80013, 0x8011b, 0x70111, 0x80073, 0x80033, 0x900c6, 0x70109, 0x80063, 0x80023, 0x900a6, 0x80003, 0x80083, 0x80043, 0x900e6, 0x70105, 0x8005b, 0x8001b, 0x90096, 0x70115, 0x8007b, 0x8003b, 0x900d6, 0x7010d, 0x8006b, 0x8002b, 0x900b6, 0x8000b, 0x8008b, 0x8004b, 0x900f6, 0x70103, 0x80057, 0x80017, 0x8011f, 0x70113, 0x80077, 0x80037, 0x900ce, 0x7010b, 0x80067, 0x80027, 0x900ae, 0x80007, 0x80087, 0x80047, 0x900ee, 0x70107, 0x8005f, 0x8001f, 0x9009e, 0x70117, 0x8007f, 0x8003f, 0x900de, 0x7010f, 0x8006f, 0x8002f, 0x900be, 0x8000f, 0x8008f, 0x8004f, 0x900fe, 0x70100, 0x80050, 0x80010, 0x80118, 0x70110, 0x80070, 0x80030, 0x900c1, 0x70108, 0x80060, 0x80020, 0x900a1, 0x80000, 0x80080, 0x80040, 0x900e1, 0x70104, 0x80058, 0x80018, 0x90091, 0x70114, 0x80078, 0x80038, 0x900d1, 0x7010c, 0x80068, 0x80028, 0x900b1, 0x80008, 0x80088, 0x80048, 0x900f1, 0x70102, 0x80054, 0x80014, 0x8011c, 0x70112, 0x80074, 0x80034, 0x900c9, 0x7010a, 0x80064, 0x80024, 0x900a9, 0x80004, 0x80084, 0x80044, 0x900e9, 0x70106, 0x8005c, 0x8001c, 0x90099, 0x70116, 0x8007c, 0x8003c, 0x900d9, 0x7010e, 0x8006c, 0x8002c, 0x900b9, 0x8000c, 0x8008c, 0x8004c, 0x900f9, 0x70101, 0x80052, 0x80012, 0x8011a, 0x70111, 0x80072, 0x80032, 0x900c5, 0x70109, 0x80062, 0x80022, 0x900a5, 0x80002, 0x80082, 0x80042, 0x900e5, 0x70105, 0x8005a, 0x8001a, 0x90095, 0x70115, 0x8007a, 0x8003a, 0x900d5, 0x7010d, 0x8006a, 0x8002a, 0x900b5, 0x8000a, 0x8008a, 0x8004a, 0x900f5, 0x70103, 0x80056, 0x80016, 0x8011e, 0x70113, 0x80076, 0x80036, 0x900cd, 0x7010b, 0x80066, 0x80026, 0x900ad, 0x80006, 0x80086, 0x80046, 0x900ed, 0x70107, 0x8005e, 0x8001e, 0x9009d, 0x70117, 0x8007e, 0x8003e, 0x900dd, 0x7010f, 0x8006e, 0x8002e, 0x900bd, 0x8000e, 0x8008e, 0x8004e, 0x900fd, 0x70100, 0x80051, 0x80011, 0x80119, 0x70110, 0x80071, 0x80031, 0x900c3, 0x70108, 0x80061, 0x80021, 0x900a3, 0x80001, 0x80081, 0x80041, 0x900e3, 0x70104, 0x80059, 0x80019, 0x90093, 0x70114, 0x80079, 0x80039, 0x900d3, 0x7010c, 0x80069, 0x80029, 0x900b3, 0x80009, 0x80089, 0x80049, 0x900f3, 0x70102, 0x80055, 0x80015, 0x8011d, 0x70112, 0x80075, 0x80035, 0x900cb, 0x7010a, 0x80065, 0x80025, 0x900ab, 0x80005, 0x80085, 0x80045, 0x900eb, 0x70106, 0x8005d, 0x8001d, 0x9009b, 0x70116, 0x8007d, 0x8003d, 0x900db, 0x7010e, 0x8006d, 0x8002d, 0x900bb, 0x8000d, 0x8008d, 0x8004d, 0x900fb, 0x70101, 0x80053, 0x80013, 0x8011b, 0x70111, 0x80073, 0x80033, 0x900c7, 0x70109, 0x80063, 0x80023, 0x900a7, 0x80003, 0x80083, 0x80043, 0x900e7, 0x70105, 0x8005b, 0x8001b, 0x90097, 0x70115, 0x8007b, 0x8003b, 0x900d7, 0x7010d, 0x8006b, 0x8002b, 0x900b7, 0x8000b, 0x8008b, 0x8004b, 0x900f7, 0x70103, 0x80057, 0x80017, 0x8011f, 0x70113, 0x80077, 0x80037, 0x900cf, 0x7010b, 0x80067, 0x80027, 0x900af, 0x80007, 0x80087, 0x80047, 0x900ef, 0x70107, 0x8005f, 0x8001f, 0x9009f, 0x70117, 0x8007f, 0x8003f, 0x900df, 0x7010f, 0x8006f, 0x8002f, 0x900bf, 0x8000f, 0x8008f, 0x8004f, 0x900ff]), 9];
   var fixedDistCodeTab = [new Int32Array([0x50000, 0x50010, 0x50008, 0x50018, 0x50004, 0x50014, 0x5000c, 0x5001c, 0x50002, 0x50012, 0x5000a, 0x5001a, 0x50006, 0x50016, 0x5000e, 0x00000, 0x50001, 0x50011, 0x50009, 0x50019, 0x50005, 0x50015, 0x5000d, 0x5001d, 0x50003, 0x50013, 0x5000b, 0x5001b, 0x50007, 0x50017, 0x5000f, 0x00000]), 5];
+
   function FlateStream(str, maybeLength) {
     this.str = str;
     this.dict = str.dict;
     var cmf = str.getByte();
     var flg = str.getByte();
+
     if (cmf === -1 || flg === -1) {
-      throw new _util.FormatError('Invalid header in flate stream: ' + cmf + ', ' + flg);
+      throw new _util.FormatError(`Invalid header in flate stream: ${cmf}, ${flg}`);
     }
+
     if ((cmf & 0x0f) !== 0x08) {
-      throw new _util.FormatError('Unknown compression method in flate stream: ' + cmf + ', ' + flg);
+      throw new _util.FormatError(`Unknown compression method in flate stream: ${cmf}, ${flg}`);
     }
+
     if (((cmf << 8) + flg) % 31 !== 0) {
-      throw new _util.FormatError('Bad FCHECK in flate stream: ' + cmf + ', ' + flg);
+      throw new _util.FormatError(`Bad FCHECK in flate stream: ${cmf}, ${flg}`);
     }
+
     if (flg & 0x20) {
-      throw new _util.FormatError('FDICT bit set in flate stream: ' + cmf + ', ' + flg);
+      throw new _util.FormatError(`FDICT bit set in flate stream: ${cmf}, ${flg}`);
     }
+
     this.codeSize = 0;
     this.codeBuf = 0;
     DecodeStream.call(this, maybeLength);
   }
+
   FlateStream.prototype = Object.create(DecodeStream.prototype);
+
   FlateStream.prototype.getBits = function FlateStream_getBits(bits) {
     var str = this.str;
     var codeSize = this.codeSize;
     var codeBuf = this.codeBuf;
     var b;
+
     while (codeSize < bits) {
       if ((b = str.getByte()) === -1) {
-        throw new _util.FormatError('Bad encoding in flate stream');
+        throw new _util.FormatError("Bad encoding in flate stream");
       }
+
       codeBuf |= b << codeSize;
       codeSize += 8;
     }
+
     b = codeBuf & (1 << bits) - 1;
     this.codeBuf = codeBuf >> bits;
     this.codeSize = codeSize -= bits;
     return b;
   };
+
   FlateStream.prototype.getCode = function FlateStream_getCode(table) {
     var str = this.str;
     var codes = table[0];
@@ -343,104 +436,134 @@ var FlateStream = function FlateStreamClosure() {
     var codeSize = this.codeSize;
     var codeBuf = this.codeBuf;
     var b;
+
     while (codeSize < maxLen) {
       if ((b = str.getByte()) === -1) {
         break;
       }
+
       codeBuf |= b << codeSize;
       codeSize += 8;
     }
+
     var code = codes[codeBuf & (1 << maxLen) - 1];
     var codeLen = code >> 16;
     var codeVal = code & 0xffff;
+
     if (codeLen < 1 || codeSize < codeLen) {
-      throw new _util.FormatError('Bad encoding in flate stream');
+      throw new _util.FormatError("Bad encoding in flate stream");
     }
+
     this.codeBuf = codeBuf >> codeLen;
     this.codeSize = codeSize - codeLen;
     return codeVal;
   };
+
   FlateStream.prototype.generateHuffmanTable = function flateStreamGenerateHuffmanTable(lengths) {
     var n = lengths.length;
     var maxLen = 0;
     var i;
+
     for (i = 0; i < n; ++i) {
       if (lengths[i] > maxLen) {
         maxLen = lengths[i];
       }
     }
+
     var size = 1 << maxLen;
     var codes = new Int32Array(size);
+
     for (var len = 1, code = 0, skip = 2; len <= maxLen; ++len, code <<= 1, skip <<= 1) {
       for (var val = 0; val < n; ++val) {
         if (lengths[val] === len) {
           var code2 = 0;
           var t = code;
+
           for (i = 0; i < len; ++i) {
             code2 = code2 << 1 | t & 1;
             t >>= 1;
           }
+
           for (i = code2; i < size; i += skip) {
             codes[i] = len << 16 | val;
           }
+
           ++code;
         }
       }
     }
+
     return [codes, maxLen];
   };
+
   FlateStream.prototype.readBlock = function FlateStream_readBlock() {
     var buffer, len;
     var str = this.str;
     var hdr = this.getBits(3);
+
     if (hdr & 1) {
       this.eof = true;
     }
+
     hdr >>= 1;
+
     if (hdr === 0) {
       var b;
+
       if ((b = str.getByte()) === -1) {
-        throw new _util.FormatError('Bad block header in flate stream');
+        throw new _util.FormatError("Bad block header in flate stream");
       }
+
       var blockLen = b;
+
       if ((b = str.getByte()) === -1) {
-        throw new _util.FormatError('Bad block header in flate stream');
+        throw new _util.FormatError("Bad block header in flate stream");
       }
+
       blockLen |= b << 8;
+
       if ((b = str.getByte()) === -1) {
-        throw new _util.FormatError('Bad block header in flate stream');
+        throw new _util.FormatError("Bad block header in flate stream");
       }
+
       var check = b;
+
       if ((b = str.getByte()) === -1) {
-        throw new _util.FormatError('Bad block header in flate stream');
+        throw new _util.FormatError("Bad block header in flate stream");
       }
+
       check |= b << 8;
+
       if (check !== (~blockLen & 0xffff) && (blockLen !== 0 || check !== 0)) {
-        throw new _util.FormatError('Bad uncompressed block length in flate stream');
+        throw new _util.FormatError("Bad uncompressed block length in flate stream");
       }
+
       this.codeBuf = 0;
       this.codeSize = 0;
-      var bufferLength = this.bufferLength;
-      buffer = this.ensureBuffer(bufferLength + blockLen);
-      var end = bufferLength + blockLen;
+      const bufferLength = this.bufferLength,
+            end = bufferLength + blockLen;
+      buffer = this.ensureBuffer(end);
       this.bufferLength = end;
+
       if (blockLen === 0) {
         if (str.peekByte() === -1) {
           this.eof = true;
         }
       } else {
-        for (var n = bufferLength; n < end; ++n) {
-          if ((b = str.getByte()) === -1) {
-            this.eof = true;
-            break;
-          }
-          buffer[n] = b;
+        const block = str.getBytes(blockLen);
+        buffer.set(block, bufferLength);
+
+        if (block.length < blockLen) {
+          this.eof = true;
         }
       }
+
       return;
     }
+
     var litCodeTable;
     var distCodeTable;
+
     if (hdr === 1) {
       litCodeTable = fixedLitCodeTab;
       distCodeTable = fixedDistCodeTab;
@@ -450,17 +573,21 @@ var FlateStream = function FlateStreamClosure() {
       var numCodeLenCodes = this.getBits(4) + 4;
       var codeLenCodeLengths = new Uint8Array(codeLenCodeMap.length);
       var i;
+
       for (i = 0; i < numCodeLenCodes; ++i) {
         codeLenCodeLengths[codeLenCodeMap[i]] = this.getBits(3);
       }
+
       var codeLenCodeTab = this.generateHuffmanTable(codeLenCodeLengths);
       len = 0;
       i = 0;
       var codes = numLitCodes + numDistCodes;
       var codeLengths = new Uint8Array(codes);
       var bitsLength, bitsOffset, what;
+
       while (i < codes) {
         var code = this.getCode(codeLenCodeTab);
+
         if (code === 16) {
           bitsLength = 2;
           bitsOffset = 3;
@@ -477,86 +604,112 @@ var FlateStream = function FlateStreamClosure() {
           codeLengths[i++] = len = code;
           continue;
         }
+
         var repeatLength = this.getBits(bitsLength) + bitsOffset;
+
         while (repeatLength-- > 0) {
           codeLengths[i++] = what;
         }
       }
+
       litCodeTable = this.generateHuffmanTable(codeLengths.subarray(0, numLitCodes));
       distCodeTable = this.generateHuffmanTable(codeLengths.subarray(numLitCodes, codes));
     } else {
-      throw new _util.FormatError('Unknown block type in flate stream');
+      throw new _util.FormatError("Unknown block type in flate stream");
     }
+
     buffer = this.buffer;
     var limit = buffer ? buffer.length : 0;
     var pos = this.bufferLength;
+
     while (true) {
       var code1 = this.getCode(litCodeTable);
+
       if (code1 < 256) {
         if (pos + 1 >= limit) {
           buffer = this.ensureBuffer(pos + 1);
           limit = buffer.length;
         }
+
         buffer[pos++] = code1;
         continue;
       }
+
       if (code1 === 256) {
         this.bufferLength = pos;
         return;
       }
+
       code1 -= 257;
       code1 = lengthDecode[code1];
       var code2 = code1 >> 16;
+
       if (code2 > 0) {
         code2 = this.getBits(code2);
       }
+
       len = (code1 & 0xffff) + code2;
       code1 = this.getCode(distCodeTable);
       code1 = distDecode[code1];
       code2 = code1 >> 16;
+
       if (code2 > 0) {
         code2 = this.getBits(code2);
       }
+
       var dist = (code1 & 0xffff) + code2;
+
       if (pos + len >= limit) {
         buffer = this.ensureBuffer(pos + len);
         limit = buffer.length;
       }
+
       for (var k = 0; k < len; ++k, ++pos) {
         buffer[pos] = buffer[pos - dist];
       }
     }
   };
+
   return FlateStream;
 }();
+
+exports.FlateStream = FlateStream;
+
 var PredictorStream = function PredictorStreamClosure() {
   function PredictorStream(str, maybeLength, params) {
     if (!(0, _primitives.isDict)(params)) {
       return str;
     }
-    var predictor = this.predictor = params.get('Predictor') || 1;
+
+    var predictor = this.predictor = params.get("Predictor") || 1;
+
     if (predictor <= 1) {
       return str;
     }
+
     if (predictor !== 2 && (predictor < 10 || predictor > 15)) {
-      throw new _util.FormatError('Unsupported predictor: ' + predictor);
+      throw new _util.FormatError(`Unsupported predictor: ${predictor}`);
     }
+
     if (predictor === 2) {
       this.readBlock = this.readBlockTiff;
     } else {
       this.readBlock = this.readBlockPng;
     }
+
     this.str = str;
     this.dict = str.dict;
-    var colors = this.colors = params.get('Colors') || 1;
-    var bits = this.bits = params.get('BitsPerComponent') || 8;
-    var columns = this.columns = params.get('Columns') || 1;
+    var colors = this.colors = params.get("Colors") || 1;
+    var bits = this.bits = params.get("BitsPerComponent") || 8;
+    var columns = this.columns = params.get("Columns") || 1;
     this.pixBytes = colors * bits + 7 >> 3;
     this.rowBytes = columns * colors * bits + 7 >> 3;
     DecodeStream.call(this, maybeLength);
     return this;
   }
+
   PredictorStream.prototype = Object.create(DecodeStream.prototype);
+
   PredictorStream.prototype.readBlockTiff = function predictorStreamReadBlockTiff() {
     var rowBytes = this.rowBytes;
     var bufferLength = this.bufferLength;
@@ -565,15 +718,18 @@ var PredictorStream = function PredictorStreamClosure() {
     var colors = this.colors;
     var rawBytes = this.str.getBytes(rowBytes);
     this.eof = !rawBytes.length;
+
     if (this.eof) {
       return;
     }
+
     var inbuf = 0,
         outbuf = 0;
     var inbits = 0,
         outbits = 0;
     var pos = bufferLength;
     var i;
+
     if (bits === 1 && colors === 1) {
       for (i = 0; i < rowBytes; ++i) {
         var c = rawBytes[i] ^ inbuf;
@@ -587,19 +743,22 @@ var PredictorStream = function PredictorStreamClosure() {
       for (i = 0; i < colors; ++i) {
         buffer[pos++] = rawBytes[i];
       }
+
       for (; i < rowBytes; ++i) {
         buffer[pos] = buffer[pos - colors] + rawBytes[i];
         pos++;
       }
     } else if (bits === 16) {
       var bytesPerPixel = colors * 2;
+
       for (i = 0; i < bytesPerPixel; ++i) {
         buffer[pos++] = rawBytes[i];
       }
+
       for (; i < rowBytes; i += 2) {
-        var sum = ((rawBytes[i] & 0xFF) << 8) + (rawBytes[i + 1] & 0xFF) + ((buffer[pos - bytesPerPixel] & 0xFF) << 8) + (buffer[pos - bytesPerPixel + 1] & 0xFF);
-        buffer[pos++] = sum >> 8 & 0xFF;
-        buffer[pos++] = sum & 0xFF;
+        var sum = ((rawBytes[i] & 0xff) << 8) + (rawBytes[i + 1] & 0xff) + ((buffer[pos - bytesPerPixel] & 0xff) << 8) + (buffer[pos - bytesPerPixel + 1] & 0xff);
+        buffer[pos++] = sum >> 8 & 0xff;
+        buffer[pos++] = sum & 0xff;
       }
     } else {
       var compArray = new Uint8Array(colors + 1);
@@ -607,100 +766,129 @@ var PredictorStream = function PredictorStreamClosure() {
       var j = 0,
           k = bufferLength;
       var columns = this.columns;
+
       for (i = 0; i < columns; ++i) {
         for (var kk = 0; kk < colors; ++kk) {
           if (inbits < bits) {
-            inbuf = inbuf << 8 | rawBytes[j++] & 0xFF;
+            inbuf = inbuf << 8 | rawBytes[j++] & 0xff;
             inbits += 8;
           }
+
           compArray[kk] = compArray[kk] + (inbuf >> inbits - bits) & bitMask;
           inbits -= bits;
           outbuf = outbuf << bits | compArray[kk];
           outbits += bits;
+
           if (outbits >= 8) {
-            buffer[k++] = outbuf >> outbits - 8 & 0xFF;
+            buffer[k++] = outbuf >> outbits - 8 & 0xff;
             outbits -= 8;
           }
         }
       }
+
       if (outbits > 0) {
         buffer[k++] = (outbuf << 8 - outbits) + (inbuf & (1 << 8 - outbits) - 1);
       }
     }
+
     this.bufferLength += rowBytes;
   };
+
   PredictorStream.prototype.readBlockPng = function predictorStreamReadBlockPng() {
     var rowBytes = this.rowBytes;
     var pixBytes = this.pixBytes;
     var predictor = this.str.getByte();
     var rawBytes = this.str.getBytes(rowBytes);
     this.eof = !rawBytes.length;
+
     if (this.eof) {
       return;
     }
+
     var bufferLength = this.bufferLength;
     var buffer = this.ensureBuffer(bufferLength + rowBytes);
     var prevRow = buffer.subarray(bufferLength - rowBytes, bufferLength);
+
     if (prevRow.length === 0) {
       prevRow = new Uint8Array(rowBytes);
     }
+
     var i,
         j = bufferLength,
         up,
         c;
+
     switch (predictor) {
       case 0:
         for (i = 0; i < rowBytes; ++i) {
           buffer[j++] = rawBytes[i];
         }
+
         break;
+
       case 1:
         for (i = 0; i < pixBytes; ++i) {
           buffer[j++] = rawBytes[i];
         }
+
         for (; i < rowBytes; ++i) {
-          buffer[j] = buffer[j - pixBytes] + rawBytes[i] & 0xFF;
+          buffer[j] = buffer[j - pixBytes] + rawBytes[i] & 0xff;
           j++;
         }
+
         break;
+
       case 2:
         for (i = 0; i < rowBytes; ++i) {
-          buffer[j++] = prevRow[i] + rawBytes[i] & 0xFF;
+          buffer[j++] = prevRow[i] + rawBytes[i] & 0xff;
         }
+
         break;
+
       case 3:
         for (i = 0; i < pixBytes; ++i) {
           buffer[j++] = (prevRow[i] >> 1) + rawBytes[i];
         }
+
         for (; i < rowBytes; ++i) {
-          buffer[j] = (prevRow[i] + buffer[j - pixBytes] >> 1) + rawBytes[i] & 0xFF;
+          buffer[j] = (prevRow[i] + buffer[j - pixBytes] >> 1) + rawBytes[i] & 0xff;
           j++;
         }
+
         break;
+
       case 4:
         for (i = 0; i < pixBytes; ++i) {
           up = prevRow[i];
           c = rawBytes[i];
           buffer[j++] = up + c;
         }
+
         for (; i < rowBytes; ++i) {
           up = prevRow[i];
           var upLeft = prevRow[i - pixBytes];
           var left = buffer[j - pixBytes];
           var p = left + up - upLeft;
           var pa = p - left;
+
           if (pa < 0) {
             pa = -pa;
           }
+
           var pb = p - up;
+
           if (pb < 0) {
             pb = -pb;
           }
+
           var pc = p - upLeft;
+
           if (pc < 0) {
             pc = -pc;
           }
+
           c = rawBytes[i];
+
           if (pa <= pb && pa <= pc) {
             buffer[j++] = left + c;
           } else if (pb <= pc) {
@@ -709,14 +897,21 @@ var PredictorStream = function PredictorStreamClosure() {
             buffer[j++] = upLeft + c;
           }
         }
+
         break;
+
       default:
-        throw new _util.FormatError('Unsupported predictor: ' + predictor);
+        throw new _util.FormatError(`Unsupported predictor: ${predictor}`);
     }
+
     this.bufferLength += rowBytes;
   };
+
   return PredictorStream;
 }();
+
+exports.PredictorStream = PredictorStream;
+
 var DecryptStream = function DecryptStreamClosure() {
   function DecryptStream(str, maybeLength, decrypt) {
     this.str = str;
@@ -726,20 +921,25 @@ var DecryptStream = function DecryptStreamClosure() {
     this.initialized = false;
     DecodeStream.call(this, maybeLength);
   }
+
   var chunkSize = 512;
   DecryptStream.prototype = Object.create(DecodeStream.prototype);
+
   DecryptStream.prototype.readBlock = function DecryptStream_readBlock() {
     var chunk;
+
     if (this.initialized) {
       chunk = this.nextChunk;
     } else {
       chunk = this.str.getBytes(chunkSize);
       this.initialized = true;
     }
+
     if (!chunk || chunk.length === 0) {
       this.eof = true;
       return;
     }
+
     this.nextChunk = this.str.getBytes(chunkSize);
     var hasMoreData = this.nextChunk && this.nextChunk.length > 0;
     var decrypt = this.decrypt;
@@ -748,114 +948,153 @@ var DecryptStream = function DecryptStreamClosure() {
     var i,
         n = chunk.length;
     var buffer = this.ensureBuffer(bufferLength + n);
+
     for (i = 0; i < n; i++) {
       buffer[bufferLength++] = chunk[i];
     }
+
     this.bufferLength = bufferLength;
   };
+
   return DecryptStream;
 }();
+
+exports.DecryptStream = DecryptStream;
+
 var Ascii85Stream = function Ascii85StreamClosure() {
   function Ascii85Stream(str, maybeLength) {
     this.str = str;
     this.dict = str.dict;
     this.input = new Uint8Array(5);
+
     if (maybeLength) {
       maybeLength = 0.8 * maybeLength;
     }
+
     DecodeStream.call(this, maybeLength);
   }
+
   Ascii85Stream.prototype = Object.create(DecodeStream.prototype);
+
   Ascii85Stream.prototype.readBlock = function Ascii85Stream_readBlock() {
-    var TILDA_CHAR = 0x7E;
-    var Z_LOWER_CHAR = 0x7A;
+    var TILDA_CHAR = 0x7e;
+    var Z_LOWER_CHAR = 0x7a;
     var EOF = -1;
     var str = this.str;
     var c = str.getByte();
-    while ((0, _util.isSpace)(c)) {
+
+    while ((0, _core_utils.isWhiteSpace)(c)) {
       c = str.getByte();
     }
+
     if (c === EOF || c === TILDA_CHAR) {
       this.eof = true;
       return;
     }
+
     var bufferLength = this.bufferLength,
         buffer;
     var i;
+
     if (c === Z_LOWER_CHAR) {
       buffer = this.ensureBuffer(bufferLength + 4);
+
       for (i = 0; i < 4; ++i) {
         buffer[bufferLength + i] = 0;
       }
+
       this.bufferLength += 4;
     } else {
       var input = this.input;
       input[0] = c;
+
       for (i = 1; i < 5; ++i) {
         c = str.getByte();
-        while ((0, _util.isSpace)(c)) {
+
+        while ((0, _core_utils.isWhiteSpace)(c)) {
           c = str.getByte();
         }
+
         input[i] = c;
+
         if (c === EOF || c === TILDA_CHAR) {
           break;
         }
       }
+
       buffer = this.ensureBuffer(bufferLength + i - 1);
       this.bufferLength += i - 1;
+
       if (i < 5) {
         for (; i < 5; ++i) {
           input[i] = 0x21 + 84;
         }
+
         this.eof = true;
       }
+
       var 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;
+        buffer[bufferLength + i] = t & 0xff;
         t >>= 8;
       }
     }
   };
+
   return Ascii85Stream;
 }();
+
+exports.Ascii85Stream = Ascii85Stream;
+
 var AsciiHexStream = function AsciiHexStreamClosure() {
   function AsciiHexStream(str, maybeLength) {
     this.str = str;
     this.dict = str.dict;
     this.firstDigit = -1;
+
     if (maybeLength) {
       maybeLength = 0.5 * maybeLength;
     }
+
     DecodeStream.call(this, maybeLength);
   }
+
   AsciiHexStream.prototype = Object.create(DecodeStream.prototype);
+
   AsciiHexStream.prototype.readBlock = function AsciiHexStream_readBlock() {
     var UPSTREAM_BLOCK_SIZE = 8000;
     var bytes = this.str.getBytes(UPSTREAM_BLOCK_SIZE);
+
     if (!bytes.length) {
       this.eof = true;
       return;
     }
+
     var maxDecodeLength = bytes.length + 1 >> 1;
     var buffer = this.ensureBuffer(this.bufferLength + maxDecodeLength);
     var bufferLength = this.bufferLength;
     var firstDigit = this.firstDigit;
+
     for (var i = 0, ii = bytes.length; i < ii; i++) {
       var ch = bytes[i],
           digit;
+
       if (ch >= 0x30 && ch <= 0x39) {
-        digit = ch & 0x0F;
+        digit = ch & 0x0f;
       } else if (ch >= 0x41 && ch <= 0x46 || ch >= 0x61 && ch <= 0x66) {
-        digit = (ch & 0x0F) + 9;
-      } else if (ch === 0x3E) {
+        digit = (ch & 0x0f) + 9;
+      } else if (ch === 0x3e) {
         this.eof = true;
         break;
       } else {
         continue;
       }
+
       if (firstDigit < 0) {
         firstDigit = digit;
       } else {
@@ -863,34 +1102,46 @@ var AsciiHexStream = function AsciiHexStreamClosure() {
         firstDigit = -1;
       }
     }
+
     if (firstDigit >= 0 && this.eof) {
       buffer[bufferLength++] = firstDigit << 4;
       firstDigit = -1;
     }
+
     this.firstDigit = firstDigit;
     this.bufferLength = bufferLength;
   };
+
   return AsciiHexStream;
 }();
+
+exports.AsciiHexStream = AsciiHexStream;
+
 var RunLengthStream = function RunLengthStreamClosure() {
   function RunLengthStream(str, maybeLength) {
     this.str = str;
     this.dict = str.dict;
     DecodeStream.call(this, maybeLength);
   }
+
   RunLengthStream.prototype = Object.create(DecodeStream.prototype);
+
   RunLengthStream.prototype.readBlock = function RunLengthStream_readBlock() {
     var repeatHeader = this.str.getBytes(2);
+
     if (!repeatHeader || repeatHeader.length < 2 || repeatHeader[0] === 128) {
       this.eof = true;
       return;
     }
+
     var buffer;
     var bufferLength = this.bufferLength;
     var n = repeatHeader[0];
+
     if (n < 128) {
       buffer = this.ensureBuffer(bufferLength + n + 1);
       buffer[bufferLength++] = repeatHeader[1];
+
       if (n > 0) {
         var source = this.str.getBytes(n);
         buffer.set(source, bufferLength);
@@ -900,14 +1151,20 @@ var RunLengthStream = function RunLengthStreamClosure() {
       n = 257 - n;
       var b = repeatHeader[1];
       buffer = this.ensureBuffer(bufferLength + n + 1);
+
       for (var i = 0; i < n; i++) {
         buffer[bufferLength++] = b;
       }
     }
+
     this.bufferLength = bufferLength;
   };
+
   return RunLengthStream;
 }();
+
+exports.RunLengthStream = RunLengthStream;
+
 var LZWStream = function LZWStreamClosure() {
   function LZWStream(str, maybeLength, earlyChange) {
     this.str = str;
@@ -916,7 +1173,7 @@ var LZWStream = function LZWStreamClosure() {
     this.bitsCached = 0;
     var maxLzwDictionarySize = 4096;
     var lzwState = {
-      earlyChange: earlyChange,
+      earlyChange,
       codeLength: 9,
       nextCode: 258,
       dictionaryValues: new Uint8Array(maxLzwDictionarySize),
@@ -925,40 +1182,51 @@ var LZWStream = function LZWStreamClosure() {
       currentSequence: new Uint8Array(maxLzwDictionarySize),
       currentSequenceLength: 0
     };
+
     for (var i = 0; i < 256; ++i) {
       lzwState.dictionaryValues[i] = i;
       lzwState.dictionaryLengths[i] = 1;
     }
+
     this.lzwState = lzwState;
     DecodeStream.call(this, maybeLength);
   }
+
   LZWStream.prototype = Object.create(DecodeStream.prototype);
+
   LZWStream.prototype.readBits = function LZWStream_readBits(n) {
     var bitsCached = this.bitsCached;
     var cachedData = this.cachedData;
+
     while (bitsCached < n) {
       var c = this.str.getByte();
+
       if (c === -1) {
         this.eof = true;
         return null;
       }
+
       cachedData = cachedData << 8 | c;
       bitsCached += 8;
     }
+
     this.bitsCached = bitsCached -= n;
     this.cachedData = cachedData;
     this.lastCode = null;
     return cachedData >>> bitsCached & (1 << n) - 1;
   };
+
   LZWStream.prototype.readBlock = function LZWStream_readBlock() {
     var blockSize = 512;
     var estimatedDecodedSize = blockSize * 2,
         decodedSizeDelta = blockSize;
     var i, j, q;
     var lzwState = this.lzwState;
+
     if (!lzwState) {
       return;
     }
+
     var earlyChange = lzwState.earlyChange;
     var nextCode = lzwState.nextCode;
     var dictionaryValues = lzwState.dictionaryValues;
@@ -971,15 +1239,18 @@ var LZWStream = function LZWStreamClosure() {
     var decodedLength = 0;
     var currentBufferLength = this.bufferLength;
     var buffer = this.ensureBuffer(this.bufferLength + estimatedDecodedSize);
+
     for (i = 0; i < blockSize; i++) {
       var code = this.readBits(codeLength);
       var hasPrev = currentSequenceLength > 0;
+
       if (code < 256) {
         currentSequence[0] = code;
         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];
@@ -997,6 +1268,7 @@ var LZWStream = function LZWStreamClosure() {
         delete this.lzwState;
         break;
       }
+
       if (hasPrev) {
         dictionaryPrevCodes[nextCode] = prevCode;
         dictionaryLengths[nextCode] = dictionaryLengths[prevCode] + 1;
@@ -1004,42 +1276,42 @@ var LZWStream = function LZWStreamClosure() {
         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;
   };
+
   return LZWStream;
 }();
+
+exports.LZWStream = LZWStream;
+
 var NullStream = function NullStreamClosure() {
   function NullStream() {
     Stream.call(this, new Uint8Array(0));
   }
+
   NullStream.prototype = Stream.prototype;
   return NullStream;
 }();
-exports.Ascii85Stream = Ascii85Stream;
-exports.AsciiHexStream = AsciiHexStream;
-exports.DecryptStream = DecryptStream;
-exports.DecodeStream = DecodeStream;
-exports.FlateStream = FlateStream;
-exports.NullStream = NullStream;
-exports.PredictorStream = PredictorStream;
-exports.RunLengthStream = RunLengthStream;
-exports.Stream = Stream;
-exports.StreamsSequenceStream = StreamsSequenceStream;
-exports.StringStream = StringStream;
-exports.LZWStream = LZWStream;
+
+exports.NullStream = NullStream;