text: /**
   * @licstart The following is the entire license notice for the
   * Javascript code in this page
   *
   * Copyright 2019 Mozilla Foundation
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *
   * @licend The above is the entire license notice for the
   * Javascript code in this page
   */
  "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 = void 0;
  
  var _util = require("../shared/util");
  
  var _primitives = require("./primitives");
  
  function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
  
  function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
  
  function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
  
  function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
  
  var Stream = function StreamClosure() {
    function Stream(arrayBuffer, start, length, dict) {
      this.bytes = arrayBuffer instanceof Uint8Array ? arrayBuffer : new Uint8Array(arrayBuffer);
      this.start = start || 0;
      this.pos = this.start;
      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() {
        var b0 = this.getByte();
        var b1 = this.getByte();
        var b2 = this.getByte();
        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;
        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;
        }
  
        var end = pos + length;
  
        if (end > strEnd) {
          end = strEnd;
        }
  
        this.pos = end;
        var subarray = bytes.subarray(pos, end);
        return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
      },
      peekByte: function Stream_peekByte() {
        var peekedByte = this.getByte();
        this.pos--;
        return peekedByte;
      },
      peekBytes: function peekBytes(length) {
        var forceClamped = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
        var bytes = this.getBytes(length, forceClamped);
        this.pos -= bytes.length;
        return bytes;
      },
      getByteRange: function 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() {
        this.pos = this.start;
      },
      moveStart: function Stream_moveStart() {
        this.start = this.pos;
      },
      makeSubStream: function Stream_makeSubStream(start, length, dict) {
        return new Stream(this.bytes.buffer, start, length, dict);
      }
    };
    return Stream;
  }();
  
  exports.Stream = Stream;
  
  var StringStream = function StringStreamClosure() {
    function StringStream(str) {
      var 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;
      this.bufferLength = 0;
      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() {
        var b0 = this.getByte();
        var b1 = this.getByte();
        var b2 = this.getByte();
        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;
        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;
          }
        } else {
          while (!this.eof) {
            this.readBlock();
          }
  
          end = this.bufferLength;
        }
  
        this.pos = end;
        var 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--;
        return peekedByte;
      },
      peekBytes: function peekBytes(length) {
        var forceClamped = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
        var bytes = this.getBytes(length, forceClamped);
        this.pos -= bytes.length;
        return bytes;
      },
      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: function 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() {
        this.pos = 0;
      },
      getBaseStreams: function DecodeStream_getBaseStreams() {
        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];
  
        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;
      var newLength = bufferLength + chunk.length;
      var buffer = this.ensureBuffer(newLength);
      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()));
        }
      }
  
      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: ".concat(cmf, ", ").concat(flg));
      }
  
      if ((cmf & 0x0f) !== 0x08) {
        throw new _util.FormatError("Unknown compression method in flate stream: ".concat(cmf, ", ").concat(flg));
      }
  
      if (((cmf << 8) + flg) % 31 !== 0) {
        throw new _util.FormatError("Bad FCHECK in flate stream: ".concat(cmf, ", ").concat(flg));
      }
  
      if (flg & 0x20) {
        throw new _util.FormatError("FDICT bit set in flate stream: ".concat(cmf, ", ").concat(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');
        }
  
        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];
      var maxLen = table[1];
      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');
      }
  
      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');
        }
  
        var blockLen = b;
  
        if ((b = str.getByte()) === -1) {
          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');
        }
  
        var check = b;
  
        if ((b = str.getByte()) === -1) {
          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');
        }
  
        this.codeBuf = 0;
        this.codeSize = 0;
        var bufferLength = this.bufferLength;
        buffer = this.ensureBuffer(bufferLength + blockLen);
        var end = bufferLength + blockLen;
        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;
          }
        }
  
        return;
      }
  
      var litCodeTable;
      var distCodeTable;
  
      if (hdr === 1) {
        litCodeTable = fixedLitCodeTab;
        distCodeTable = fixedDistCodeTab;
      } else if (hdr === 2) {
        var numLitCodes = this.getBits(5) + 257;
        var numDistCodes = this.getBits(5) + 1;
        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;
            what = len;
          } else if (code === 17) {
            bitsLength = 3;
            bitsOffset = 3;
            what = len = 0;
          } else if (code === 18) {
            bitsLength = 7;
            bitsOffset = 11;
            what = len = 0;
          } else {
            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');
      }
  
      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;
  
      if (predictor <= 1) {
        return str;
      }
  
      if (predictor !== 2 && (predictor < 10 || predictor > 15)) {
        throw new _util.FormatError("Unsupported predictor: ".concat(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;
      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;
      var buffer = this.ensureBuffer(bufferLength + rowBytes);
      var bits = this.bits;
      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;
          c ^= c >> 1;
          c ^= c >> 2;
          c ^= c >> 4;
          inbuf = (c & 1) << 7;
          buffer[pos++] = c;
        }
      } else if (bits === 8) {
        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;
        }
      } else {
        var compArray = new Uint8Array(colors + 1);
        var bitMask = (1 << bits) - 1;
        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;
              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;
              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;
            j++;
          }
  
          break;
  
        case 2:
          for (i = 0; i < rowBytes; ++i) {
            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;
            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) {
              buffer[j++] = up + c;
            } else {
              buffer[j++] = upLeft + c;
            }
          }
  
          break;
  
        default:
          throw new _util.FormatError("Unsupported predictor: ".concat(predictor));
      }
  
      this.bufferLength += rowBytes;
    };
  
    return PredictorStream;
  }();
  
  exports.PredictorStream = PredictorStream;
  
  var DecryptStream = function DecryptStreamClosure() {
    function DecryptStream(str, maybeLength, decrypt) {
      this.str = str;
      this.dict = str.dict;
      this.decrypt = decrypt;
      this.nextChunk = null;
      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;
      chunk = decrypt(chunk, !hasMoreData);
      var bufferLength = this.bufferLength;
      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 EOF = -1;
      var str = this.str;
      var c = str.getByte();
  
      while ((0, _util.isSpace)(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)) {
            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;
          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;
        } else if (ch >= 0x41 && ch <= 0x46 || ch >= 0x61 && ch <= 0x66) {
          digit = (ch & 0x0F) + 9;
        } else if (ch === 0x3E) {
          this.eof = true;
          break;
        } else {
          continue;
        }
  
        if (firstDigit < 0) {
          firstDigit = digit;
        } else {
          buffer[bufferLength++] = firstDigit << 4 | digit;
          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);
          bufferLength += n;
        }
      } else {
        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;
      this.dict = str.dict;
      this.cachedData = 0;
      this.bitsCached = 0;
      var maxLzwDictionarySize = 4096;
      var lzwState = {
        earlyChange: earlyChange,
        codeLength: 9,
        nextCode: 258,
        dictionaryValues: new Uint8Array(maxLzwDictionarySize),
        dictionaryLengths: new Uint16Array(maxLzwDictionarySize),
        dictionaryPrevCodes: new Uint16Array(maxLzwDictionarySize),
        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;
      var dictionaryLengths = lzwState.dictionaryLengths;
      var dictionaryPrevCodes = lzwState.dictionaryPrevCodes;
      var codeLength = lzwState.codeLength;
      var prevCode = lzwState.prevCode;
      var currentSequence = lzwState.currentSequence;
      var currentSequenceLength = lzwState.currentSequenceLength;
      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];
            }
          } 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;
          dictionaryLengths[nextCode] = dictionaryLengths[prevCode] + 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;
    };
  
    return LZWStream;
  }();
  
  exports.LZWStream = LZWStream;
  
  var NullStream = function NullStreamClosure() {
    function NullStream() {
      Stream.call(this, new Uint8Array(0));
    }
  
    NullStream.prototype = Stream.prototype;
    return NullStream;
  }();
  
  exports.NullStream = NullStream;