pdfjs.parser.js

      }
      var code = codes[codeBuf & ((1 << maxLen) - 1)];
      var codeLen = code >> 16;
      var codeVal = code & 0xffff;
      if (codeLen < 1 || codeSize < codeLen) {
        error("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;

      // find max code length
      var maxLen = 0;
      var i;
      for (i = 0; i < n; ++i) {
        if (lengths[i] > maxLen) {
          maxLen = lengths[i];
        }
      }

      // build the table
      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) {
            // bit-reverse the code
            var code2 = 0;
            var t = code;
            for (i = 0; i < len; ++i) {
              code2 = (code2 << 1) | (t & 1);
              t >>= 1;
            }

            // fill the table entries
            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;
      // read block header
      var hdr = this.getBits(3);
      if (hdr & 1) {
        this.eof = true;
      }
      hdr >>= 1;

      if (hdr === 0) {
        // uncompressed block
        var b;

        if ((b = str.getByte()) === -1) {
          error("Bad block header in flate stream");
        }
        var blockLen = b;
        if ((b = str.getByte()) === -1) {
          error("Bad block header in flate stream");
        }
        blockLen |= b << 8;
        if ((b = str.getByte()) === -1) {
          error("Bad block header in flate stream");
        }
        var check = b;
        if ((b = str.getByte()) === -1) {
          error("Bad block header in flate stream");
        }
        check |= b << 8;
        if (check !== (~blockLen & 0xffff) && (blockLen !== 0 || check !== 0)) {
          // Ignoring error for bad "empty" block (see issue 1277)
          error("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) {
        // compressed block, fixed codes
        litCodeTable = fixedLitCodeTab;
        distCodeTable = fixedDistCodeTab;
      } else if (hdr === 2) {
        // compressed block, dynamic codes
        var numLitCodes = this.getBits(5) + 257;
        var numDistCodes = this.getBits(5) + 1;
        var numCodeLenCodes = this.getBits(4) + 4;

        // build the code lengths code table
        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);

        // build the literal and distance code tables
        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 {
        error("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;
  })();

  var PredictorStream = (function PredictorStreamClosure() {
    function PredictorStream(str, maybeLength, params) {
      var predictor = (this.predictor = params.get("Predictor") || 1);

      if (predictor <= 1) {
        return str; // no prediction
      }
      if (predictor !== 2 && (predictor < 10 || predictor > 15)) {
        error("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);

      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) {
        for (i = 0; i < rowBytes; ++i) {
          var c = rawBytes[i];
          inbuf = (inbuf << 8) | c;
          // bitwise addition is exclusive or
          // first shift inbuf and then add
          buffer[pos++] = (c ^ (inbuf >> colors)) & 0xff;
          // truncate inbuf (assumes colors < 16)
          inbuf &= 0xffff;
        }
      } 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 {
        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:
          // we need to save the up left pixels values. the simplest way
          // is to create a new buffer
          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:
          error("Unsupported predictor: " + predictor);
      }
      this.bufferLength += rowBytes;
    };

    return PredictorStream;
  })();

  /**
   * Depending on the type of JPEG a JpegStream is handled in different ways. For
   * JPEG's that are supported natively such as DeviceGray and DeviceRGB the image
   * data is stored and then loaded by the browser.  For unsupported JPEG's we use
   * a library to decode these images and the stream behaves like all the other
   * DecodeStreams.
   */
  var JpegStream = (function JpegStreamClosure() {
    function JpegStream(stream, maybeLength, dict, xref) {
      // Some images may contain 'junk' before the SOI (start-of-image) marker.
      // Note: this seems to mainly affect inline images.
      var ch;
      while ((ch = stream.getByte()) !== -1) {
        if (ch === 0xff) {
          // Find the first byte of the SOI marker (0xFFD8).
          stream.skip(-1); // Reset the stream position to the SOI.
          break;
        }
      }
      this.stream = stream;
      this.maybeLength = maybeLength;
      this.dict = dict;

      DecodeStream.call(this, maybeLength);
    }

    JpegStream.prototype = Object.create(DecodeStream.prototype);

    Object.defineProperty(JpegStream.prototype, "bytes", {
      get: function JpegStream_bytes() {
        // If this.maybeLength is null, we'll get the entire stream.
        return shadow(this, "bytes", this.stream.getBytes(this.maybeLength));
      },
      configurable: true
    });

    JpegStream.prototype.ensureBuffer = function JpegStream_ensureBuffer(req) {
      if (this.bufferLength) {
        return;
      }
      try {
        var jpegImage = new JpegImage();

        // checking if values needs to be transformed before conversion
        if (this.forceRGB && this.dict && isArray(this.dict.get("Decode"))) {
          var decodeArr = this.dict.get("Decode");
          var bitsPerComponent = this.dict.get("BitsPerComponent") || 8;
          var decodeArrLength = decodeArr.length;
          var transform = new Int32Array(decodeArrLength);
          var transformNeeded = false;
          var maxValue = (1 << bitsPerComponent) - 1;
          for (var i = 0; i < decodeArrLength; i += 2) {
            transform[i] = ((decodeArr[i + 1] - decodeArr[i]) * 256) | 0;
            transform[i + 1] = (decodeArr[i] * maxValue) | 0;
            if (transform[i] !== 256 || transform[i + 1] !== 0) {
              transformNeeded = true;
            }
          }
          if (transformNeeded) {
            jpegImage.decodeTransform = transform;
          }
        }

        jpegImage.parse(this.bytes);
        var data = jpegImage.getData(
          this.drawWidth,
          this.drawHeight,
          this.forceRGB
        );
        this.buffer = data;
        this.bufferLength = data.length;
        this.eof = true;
      } catch (e) {
        error("JPEG error: " + e);
      }
    };

    JpegStream.prototype.getBytes = function JpegStream_getBytes(length) {
      this.ensureBuffer();
      return this.buffer;
    };

    JpegStream.prototype.getIR = function JpegStream_getIR() {
      return PDFJS.createObjectURL(this.bytes, "image/jpeg");
    };
    /**
     * Checks if the image can be decoded and displayed by the browser without any
     * further processing such as color space conversions.
     */
    JpegStream.prototype.isNativelySupported = function JpegStream_isNativelySupported(
      xref,
      res
    ) {
      var cs = ColorSpace.parse(this.dict.get("ColorSpace", "CS"), xref, res);
      return (
        (cs.name === "DeviceGray" || cs.name === "DeviceRGB") &&
        cs.isDefaultDecode(this.dict.get("Decode", "D"))
      );
    };
    /**
     * Checks if the image can be decoded by the browser.
     */
    JpegStream.prototype.isNativelyDecodable = function JpegStream_isNativelyDecodable(
      xref,
      res
    ) {
      var cs = ColorSpace.parse(this.dict.get("ColorSpace", "CS"), xref, res);
      return (
        (cs.numComps === 1 || cs.numComps === 3) &&
        cs.isDefaultDecode(this.dict.get("Decode", "D"))
      );
    };

    return JpegStream;
  })();

  /**
   * For JPEG 2000's we use a library to decode these images and
   * the stream behaves like all the other DecodeStreams.
   */
  var JpxStream = (function JpxStreamClosure() {
    function JpxStream(stream, maybeLength, dict) {
      this.stream = stream;
      this.maybeLength = maybeLength;
      this.dict = dict;

      DecodeStream.call(this, maybeLength);
    }

    JpxStream.prototype = Object.create(DecodeStream.prototype);

    Object.defineProperty(JpxStream.prototype, "bytes", {
      get: function JpxStream_bytes() {
        // If this.maybeLength is null, we'll get the entire stream.
        return shadow(this, "bytes", this.stream.getBytes(this.maybeLength));
      },
      configurable: true
    });

    JpxStream.prototype.ensureBuffer = function JpxStream_ensureBuffer(req) {
      if (this.bufferLength) {
        return;
      }

      var jpxImage = new JpxImage();
      jpxImage.parse(this.bytes);

      var width = jpxImage.width;
      var height = jpxImage.height;
      var componentsCount = jpxImage.componentsCount;
      var tileCount = jpxImage.tiles.length;
      if (tileCount === 1) {
        this.buffer = jpxImage.tiles[0].items;
      } else {
        var data = new Uint8Array(width * height * componentsCount);

        for (var k = 0; k < tileCount; k++) {
          var tileComponents = jpxImage.tiles[k];
          var tileWidth = tileComponents.width;
          var tileHeight = tileComponents.height;
          var tileLeft = tileComponents.left;
          var tileTop = tileComponents.top;

          var src = tileComponents.items;
          var srcPosition = 0;
          var dataPosition = (width * tileTop + tileLeft) * componentsCount;
          var imgRowSize = width * componentsCount;
          var tileRowSize = tileWidth * componentsCount;

          for (var j = 0; j < tileHeight; j++) {
            var rowBytes = src.subarray(srcPosition, srcPosition + tileRowSize);
            data.set(rowBytes, dataPosition);
            srcPosition += tileRowSize;
            dataPosition += imgRowSize;
          }
        }
        this.buffer = data;
      }
      this.bufferLength = this.buffer.length;
      this.eof = true;
    };

    return JpxStream;
  })();

  /**
   * For JBIG2's we use a library to decode these images and
   * the stream behaves like all the other DecodeStreams.
   */
  var Jbig2Stream = (function Jbig2StreamClosure() {
    function Jbig2Stream(stream, maybeLength, dict) {
      this.stream = stream;
      this.maybeLength = maybeLength;
      this.dict = dict;

      DecodeStream.call(this, maybeLength);
    }

    Jbig2Stream.prototype = Object.create(DecodeStream.prototype);

    Object.defineProperty(Jbig2Stream.prototype, "bytes", {
      get: function Jbig2Stream_bytes() {
        // If this.maybeLength is null, we'll get the entire stream.
        return shadow(this, "bytes", this.stream.getBytes(this.maybeLength));
      },
      configurable: true
    });

    Jbig2Stream.prototype.ensureBuffer = function Jbig2Stream_ensureBuffer(
      req
    ) {
      if (this.bufferLength) {
        return;
      }

      var jbig2Image = new Jbig2Image();

      var chunks = [],
        xref = this.dict.xref;
      var decodeParams = xref.fetchIfRef(this.dict.get("DecodeParms"));

      // According to the PDF specification, DecodeParms can be either
      // a dictionary, or an array whose elements are dictionaries.
      if (isArray(decodeParams)) {
        if (decodeParams.length > 1) {
          warn(
            "JBIG2 - 'DecodeParms' array with multiple elements " +
              "not supported."
          );
        }
        decodeParams = xref.fetchIfRef(decodeParams[0]);
      }
      if (decodeParams && decodeParams.has("JBIG2Globals")) {
        var globalsStream = decodeParams.get("JBIG2Globals");
        var globals = globalsStream.getBytes();
        chunks.push({ data: globals, start: 0, end: globals.length });
      }
      chunks.push({ data: this.bytes, start: 0, end: this.bytes.length });
      var data = jbig2Image.parseChunks(chunks);
      var dataLength = data.length;

      // JBIG2 had black as 1 and white as 0, inverting the colors
      for (var i = 0; i < dataLength; i++) {
        data[i] ^= 0xff;
      }

      this.buffer = data;
      this.bufferLength = dataLength;
      this.eof = true;
    };

    return Jbig2Stream;
  })();

  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;
  })();

  var Ascii85Stream = (function Ascii85StreamClosure() {
    function Ascii85Stream(str, maybeLength) {
      this.str = str;
      this.dict = str.dict;
      this.input = new Uint8Array(5);

      // Most streams increase in size when decoded, but Ascii85 streams
      // typically shrink by ~20%.
      if (maybeLength) {
        maybeLength = 0.8 * maybeLength;
      }
      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; // 'z'
      var EOF = -1;

      var str = this.str;

      var c = str.getByte();
      while (Lexer.isSpace(c)) {
        c = str.getByte();
      }

      if (c === EOF || c === TILDA_CHAR) {
        this.eof = true;
        return;
      }

      var bufferLength = this.bufferLength,
        buffer;
      var i;

      // special code for z
      if (c === Z_LOWER_CHAR) {
        buffer = this.ensureBuffer(bufferLength + 4);
        for (i = 0; i < 4; ++i) {
          buffer[bufferLength + i] = 0;
        }
        this.bufferLength += 4;
      } else {
        var input = this.input;
        input[0] = c;
        for (i = 1; i < 5; ++i) {
          c = str.getByte();
          while (Lexer.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;

        // partial ending;
        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;
  })();

  var AsciiHexStream = (function AsciiHexStreamClosure() {
    function AsciiHexStream(str, maybeLength) {
      this.str = str;
      this.dict = str.dict;

      this.firstDigit = -1;

      // Most streams increase in size when decoded, but AsciiHex streams shrink
      // by 50%.
      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) {
          // '0'-'9'
          digit = ch & 0x0f;
        } else if ((ch >= 0x41 && ch <= 0x46) || (ch >= 0x61 && ch <= 0x66)) {
          // 'A'-'Z', 'a'-'z'
          digit = (ch & 0x0f) + 9;
        } else if (ch === 0x3e) {
          // '>'
          this.eof = true;
          break;
        } else {
          // probably whitespace
          continue; // ignoring
        }
        if (firstDigit < 0) {
          firstDigit = digit;
        } else {
          buffer[bufferLength++] = (firstDigit << 4) | digit;
          firstDigit = -1;
        }
      }
      if (firstDigit >= 0 && this.eof) {
        // incomplete byte
        buffer[bufferLength++] = firstDigit << 4;
        firstDigit = -1;
      }
      this.firstDigit = firstDigit;
      this.bufferLength = bufferLength;
    };

    return 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() {
      // 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.
      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) {
        // copy n bytes
        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;
  })();

  var CCITTFaxStream = (function CCITTFaxStreamClosure() {
    var ccittEOL = -2;
    var twoDimPass = 0;
    var twoDimHoriz = 1;
    var twoDimVert0 = 2;
    var twoDimVertR1 = 3;
    var twoDimVertL1 = 4;
    var twoDimVertR2 = 5;
    var twoDimVertL2 = 6;
    var twoDimVertR3 = 7;
    var twoDimVertL3 = 8;

    var twoDimTable = [
      [-1, -1],
      [-1, -1], // 000000x
      [7, twoDimVertL3], // 0000010
      [7, twoDimVertR3], // 0000011
      [6, twoDimVertL2],
      [6, twoDimVertL2], // 000010x
      [6, twoDimVertR2],
      [6, twoDimVertR2], // 000011x
      [4, twoDimPass],
      [4, twoDimPass], // 0001xxx
      [4, twoDimPass],
      [4, twoDimPass],
      [4, twoDimPass],
      [4, twoDimPass],
      [4, twoDimPass],
      [4, twoDimPass],
      [3, twoDimHoriz],
      [3, twoDimHoriz], // 001xxxx
      [3, twoDimHoriz],
      [3, twoDimHoriz],
      [3, twoDimHoriz],
      [3, twoDimHoriz],
      [3, twoDimHoriz],
      [3, twoDimHoriz],
      [3, twoDimHoriz],
      [3, twoDimHoriz],
      [3, twoDimHoriz],
      [3, twoDimHoriz],
      [3, twoDimHoriz],
      [3, twoDimHoriz],
      [3, twoDimHoriz],
      [3, twoDimHoriz],
      [3, twoDimVertL1],
      [3, twoDimVertL1], // 010xxxx
      [3, twoDimVertL1],
      [3, twoDimVertL1],
      [3, twoDimVertL1],
      [3, twoDimVertL1],
      [3, twoDimVertL1],
      [3, twoDimVertL1],
      [3, twoDimVertL1],
      [3, twoDimVertL1],
      [3, twoDimVertL1],
      [3, twoDimVertL1],
      [3, twoDimVertL1],
      [3, twoDimVertL1],
      [3, twoDimVertL1],
      [3, twoDimVertL1],
      [3, twoDimVertR1],
      [3, twoDimVertR1], // 011xxxx
      [3, twoDimVertR1],
      [3, twoDimVertR1],
      [3, twoDimVertR1],
      [3, twoDimVertR1],
      [3, twoDimVertR1],
      [3, twoDimVertR1],
      [3, twoDimVertR1],
      [3, twoDimVertR1],
      [3, twoDimVertR1],
      [3, twoDimVertR1],
      [3, twoDimVertR1],
      [3, twoDimVertR1],
      [3, twoDimVertR1],
      [3, twoDimVertR1],
      [1, twoDimVert0],
      [1, twoDimVert0], // 1xxxxxx
      [1, twoDimVert0],