pdfjs.parser.js

          }
        }
        return stream.pos - 4 - startPos;
      },
      /**
       * Find the EOI (end-of-image) marker 0xFFD9 of the stream.
       * @returns {number} The inline stream length.
       */
      findDCTDecodeInlineStreamEnd: function Parser_findDCTDecodeInlineStreamEnd(
        stream
      ) {
        var startPos = stream.pos,
          foundEOI = false,
          b,
          markerLength,
          length;
        while ((b = stream.getByte()) !== -1) {
          if (b !== 0xff) {
            // Not a valid marker.
            continue;
          }
          switch (stream.getByte()) {
            case 0x00: // Byte stuffing.
              // 0xFF00 appears to be a very common byte sequence in JPEG images.
              break;

            case 0xff: // Fill byte.
              // Avoid skipping a valid marker, resetting the stream position.
              stream.skip(-1);
              break;

            case 0xd9: // EOI
              foundEOI = true;
              break;

            case 0xc0: // SOF0
            case 0xc1: // SOF1
            case 0xc2: // SOF2
            case 0xc3: // SOF3

            case 0xc5: // SOF5
            case 0xc6: // SOF6
            case 0xc7: // SOF7

            case 0xc9: // SOF9
            case 0xca: // SOF10
            case 0xcb: // SOF11

            case 0xcd: // SOF13
            case 0xce: // SOF14
            case 0xcf: // SOF15

            case 0xc4: // DHT
            case 0xcc: // DAC

            case 0xda: // SOS
            case 0xdb: // DQT
            case 0xdc: // DNL
            case 0xdd: // DRI
            case 0xde: // DHP
            case 0xdf: // EXP

            case 0xe0: // APP0
            case 0xe1: // APP1
            case 0xe2: // APP2
            case 0xe3: // APP3
            case 0xe4: // APP4
            case 0xe5: // APP5
            case 0xe6: // APP6
            case 0xe7: // APP7
            case 0xe8: // APP8
            case 0xe9: // APP9
            case 0xea: // APP10
            case 0xeb: // APP11
            case 0xec: // APP12
            case 0xed: // APP13
            case 0xee: // APP14
            case 0xef: // APP15

            case 0xfe: // COM
              // The marker should be followed by the length of the segment.
              markerLength = stream.getUint16();
              if (markerLength > 2) {
                // |markerLength| contains the byte length of the marker segment,
                // including its own length (2 bytes) and excluding the marker.
                stream.skip(markerLength - 2); // Jump to the next marker.
              } else {
                // The marker length is invalid, resetting the stream position.
                stream.skip(-2);
              }
              break;
          }
          if (foundEOI) {
            break;
          }
        }
        length = stream.pos - startPos;
        if (b === -1) {
          warn(
            "Inline DCTDecode image stream: " +
              "EOI marker not found, searching for /EI/ instead."
          );
          stream.skip(-length); // Reset the stream position.
          return this.findDefaultInlineStreamEnd(stream);
        }
        this.inlineStreamSkipEI(stream);
        return length;
      },
      /**
       * Find the EOD (end-of-data) marker '~>' (i.e. TILDE + GT) of the stream.
       * @returns {number} The inline stream length.
       */
      findASCII85DecodeInlineStreamEnd: function Parser_findASCII85DecodeInlineStreamEnd(
        stream
      ) {
        var TILDE = 0x7e,
          GT = 0x3e;
        var startPos = stream.pos,
          ch,
          length;
        while ((ch = stream.getByte()) !== -1) {
          if (ch === TILDE && stream.peekByte() === GT) {
            stream.skip();
            break;
          }
        }
        length = stream.pos - startPos;
        if (ch === -1) {
          warn(
            "Inline ASCII85Decode image stream: " +
              "EOD marker not found, searching for /EI/ instead."
          );
          stream.skip(-length); // Reset the stream position.
          return this.findDefaultInlineStreamEnd(stream);
        }
        this.inlineStreamSkipEI(stream);
        return length;
      },
      /**
       * Find the EOD (end-of-data) marker '>' (i.e. GT) of the stream.
       * @returns {number} The inline stream length.
       */
      findASCIIHexDecodeInlineStreamEnd: function Parser_findASCIIHexDecodeInlineStreamEnd(
        stream
      ) {
        var GT = 0x3e;
        var startPos = stream.pos,
          ch,
          length;
        while ((ch = stream.getByte()) !== -1) {
          if (ch === GT) {
            break;
          }
        }
        length = stream.pos - startPos;
        if (ch === -1) {
          warn(
            "Inline ASCIIHexDecode image stream: " +
              "EOD marker not found, searching for /EI/ instead."
          );
          stream.skip(-length); // Reset the stream position.
          return this.findDefaultInlineStreamEnd(stream);
        }
        this.inlineStreamSkipEI(stream);
        return length;
      },
      /**
       * Skip over the /EI/ for streams where we search for an EOD marker.
       */
      inlineStreamSkipEI: function Parser_inlineStreamSkipEI(stream) {
        var E = 0x45,
          I = 0x49;
        var state = 0,
          ch;
        while ((ch = stream.getByte()) !== -1) {
          if (state === 0) {
            state = ch === E ? 1 : 0;
          } else if (state === 1) {
            state = ch === I ? 2 : 0;
          } else if (state === 2) {
            break;
          }
        }
      },
      makeInlineImage: function Parser_makeInlineImage(cipherTransform) {
        var lexer = this.lexer;
        var stream = lexer.stream;

        // Parse dictionary.
        var dict = new Dict(this.xref);
        while (!isCmd(this.buf1, "ID") && !isEOF(this.buf1)) {
          if (!isName(this.buf1)) {
            error("Dictionary key must be a name object");
          }
          var key = this.buf1.name;
          this.shift();
          if (isEOF(this.buf1)) {
            break;
          }
          dict.set(key, this.getObj(cipherTransform));
        }

        // Extract the name of the first (i.e. the current) image filter.
        var filter = dict.get("Filter", "F"),
          filterName;
        if (isName(filter)) {
          filterName = filter.name;
        } else if (isArray(filter) && isName(filter[0])) {
          filterName = filter[0].name;
        }

        // Parse image stream.
        var startPos = stream.pos,
          length,
          i,
          ii;
        if (filterName === "DCTDecode" || filterName === "DCT") {
          length = this.findDCTDecodeInlineStreamEnd(stream);
        } else if (filterName === "ASCII85Decide" || filterName === "A85") {
          length = this.findASCII85DecodeInlineStreamEnd(stream);
        } else if (filterName === "ASCIIHexDecode" || filterName === "AHx") {
          length = this.findASCIIHexDecodeInlineStreamEnd(stream);
        } else {
          length = this.findDefaultInlineStreamEnd(stream);
        }
        var imageStream = stream.makeSubStream(startPos, length, dict);

        // Cache all images below the MAX_LENGTH_TO_CACHE threshold by their
        // adler32 checksum.
        var adler32;
        if (length < MAX_LENGTH_TO_CACHE) {
          var imageBytes = imageStream.getBytes();
          imageStream.reset();

          var a = 1;
          var b = 0;
          for (i = 0, ii = imageBytes.length; i < ii; ++i) {
            // No modulo required in the loop if imageBytes.length < 5552.
            a += imageBytes[i] & 0xff;
            b += a;
          }
          adler32 = (b % 65521 << 16) | a % 65521;

          if (this.imageCache.adler32 === adler32) {
            this.buf2 = Cmd.get("EI");
            this.shift();

            this.imageCache[adler32].reset();
            return this.imageCache[adler32];
          }
        }

        if (cipherTransform) {
          imageStream = cipherTransform.createStream(imageStream, length);
        }

        imageStream = this.filter(imageStream, dict, length);
        imageStream.dict = dict;
        if (adler32 !== undefined) {
          imageStream.cacheKey = "inline_" + length + "_" + adler32;
          this.imageCache[adler32] = imageStream;
        }

        this.buf2 = Cmd.get("EI");
        this.shift();

        return imageStream;
      },
      makeStream: function Parser_makeStream(dict, cipherTransform) {
        var lexer = this.lexer;
        var stream = lexer.stream;

        // get stream start position
        lexer.skipToNextLine();
        var pos = stream.pos - 1;

        // get length
        var length = dict.get("Length");
        if (!isInt(length)) {
          info("Bad " + length + " attribute in stream");
          length = 0;
        }

        // skip over the stream data
        stream.pos = pos + length;
        lexer.nextChar();

        // Shift '>>' and check whether the new object marks the end of the stream
        if (this.tryShift() && isCmd(this.buf2, "endstream")) {
          this.shift(); // 'stream'
        } else {
          // bad stream length, scanning for endstream
          stream.pos = pos;
          var SCAN_BLOCK_SIZE = 2048;
          var ENDSTREAM_SIGNATURE_LENGTH = 9;
          var ENDSTREAM_SIGNATURE = [
            0x65,
            0x6e,
            0x64,
            0x73,
            0x74,
            0x72,
            0x65,
            0x61,
            0x6d
          ];
          var skipped = 0,
            found = false,
            i,
            j;
          while (stream.pos < stream.end) {
            var scanBytes = stream.peekBytes(SCAN_BLOCK_SIZE);
            var scanLength = scanBytes.length - ENDSTREAM_SIGNATURE_LENGTH;
            if (scanLength <= 0) {
              break;
            }
            found = false;
            for (i = 0, j = 0; i < scanLength; i++) {
              var b = scanBytes[i];
              if (b !== ENDSTREAM_SIGNATURE[j]) {
                i -= j;
                j = 0;
              } else {
                j++;
                if (j >= ENDSTREAM_SIGNATURE_LENGTH) {
                  i++;
                  found = true;
                  break;
                }
              }
            }
            if (found) {
              skipped += i - ENDSTREAM_SIGNATURE_LENGTH;
              stream.pos += i - ENDSTREAM_SIGNATURE_LENGTH;
              break;
            }
            skipped += scanLength;
            stream.pos += scanLength;
          }
          if (!found) {
            error("Missing endstream");
          }
          length = skipped;

          lexer.nextChar();
          this.shift();
          this.shift();
        }
        this.shift(); // 'endstream'

        stream = stream.makeSubStream(pos, length, dict);
        if (cipherTransform) {
          stream = cipherTransform.createStream(stream, length);
        }
        stream = this.filter(stream, dict, length);
        stream.dict = dict;
        return stream;
      },
      filter: function Parser_filter(stream, dict, length) {
        var filter = dict.get("Filter", "F");
        var params = dict.get("DecodeParms", "DP");
        if (isName(filter)) {
          return this.makeFilter(stream, filter.name, length, params);
        }

        var maybeLength = length;
        if (isArray(filter)) {
          var filterArray = filter;
          var paramsArray = params;
          for (var i = 0, ii = filterArray.length; i < ii; ++i) {
            filter = filterArray[i];
            if (!isName(filter)) {
              error("Bad filter name: " + filter);
            }

            params = null;
            if (isArray(paramsArray) && i in paramsArray) {
              params = paramsArray[i];
            }
            stream = this.makeFilter(stream, filter.name, maybeLength, params);
            // after the first stream the length variable is invalid
            maybeLength = null;
          }
        }
        return stream;
      },
      makeFilter: function Parser_makeFilter(
        stream,
        name,
        maybeLength,
        params
      ) {
        if (stream.dict.get("Length") === 0 && !maybeLength) {
          warn('Empty "' + name + '" stream.');
          return new NullStream(stream);
        }
        try {
          if (params && this.xref) {
            params = this.xref.fetchIfRef(params);
          }
          var xrefStreamStats = this.xref.stats.streamTypes;
          if (name === "FlateDecode" || name === "Fl") {
            xrefStreamStats[StreamType.FLATE] = true;
            if (params) {
              return new PredictorStream(
                new FlateStream(stream, maybeLength),
                maybeLength,
                params
              );
            }
            return new FlateStream(stream, maybeLength);
          }
          if (name === "LZWDecode" || name === "LZW") {
            xrefStreamStats[StreamType.LZW] = true;
            var earlyChange = 1;
            if (params) {
              if (params.has("EarlyChange")) {
                earlyChange = params.get("EarlyChange");
              }
              return new PredictorStream(
                new LZWStream(stream, maybeLength, earlyChange),
                maybeLength,
                params
              );
            }
            return new LZWStream(stream, maybeLength, earlyChange);
          }
          if (name === "DCTDecode" || name === "DCT") {
            xrefStreamStats[StreamType.DCT] = true;
            return new JpegStream(stream, maybeLength, stream.dict, this.xref);
          }
          if (name === "JPXDecode" || name === "JPX") {
            xrefStreamStats[StreamType.JPX] = true;
            return new JpxStream(stream, maybeLength, stream.dict);
          }
          if (name === "ASCII85Decode" || name === "A85") {
            xrefStreamStats[StreamType.A85] = true;
            return new Ascii85Stream(stream, maybeLength);
          }
          if (name === "ASCIIHexDecode" || name === "AHx") {
            xrefStreamStats[StreamType.AHX] = true;
            return new AsciiHexStream(stream, maybeLength);
          }
          if (name === "CCITTFaxDecode" || name === "CCF") {
            xrefStreamStats[StreamType.CCF] = true;
            return new CCITTFaxStream(stream, maybeLength, params);
          }
          if (name === "RunLengthDecode" || name === "RL") {
            xrefStreamStats[StreamType.RL] = true;
            return new RunLengthStream(stream, maybeLength);
          }
          if (name === "JBIG2Decode") {
            xrefStreamStats[StreamType.JBIG] = true;
            return new Jbig2Stream(stream, maybeLength, stream.dict);
          }
          warn('filter "' + name + '" not supported yet');
          return stream;
        } catch (ex) {
          if (ex instanceof MissingDataException) {
            throw ex;
          }
          warn('Invalid stream: "' + ex + '"');
          return new NullStream(stream);
        }
      }
    };

    return Parser;
  })();

  var Lexer = (function LexerClosure() {
    function Lexer(stream, knownCommands) {
      this.stream = stream;
      this.nextChar();

      // While lexing, we build up many strings one char at a time. Using += for
      // this can result in lots of garbage strings. It's better to build an
      // array of single-char strings and then join() them together at the end.
      // And reusing a single array (i.e. |this.strBuf|) over and over for this
      // purpose uses less memory than using a new array for each string.
      this.strBuf = [];

      // The PDFs might have "glued" commands with other commands, operands or
      // literals, e.g. "q1". The knownCommands is a dictionary of the valid
      // commands and their prefixes. The prefixes are built the following way:
      // if there a command that is a prefix of the other valid command or
      // literal (e.g. 'f' and 'false') the following prefixes must be included,
      // 'fa', 'fal', 'fals'. The prefixes are not needed, if the command has no
      // other commands or literals as a prefix. The knowCommands is optional.
      this.knownCommands = knownCommands;
    }

    Lexer.isSpace = function Lexer_isSpace(ch) {
      // Space is one of the following characters: SPACE, TAB, CR or LF.
      return ch === 0x20 || ch === 0x09 || ch === 0x0d || ch === 0x0a;
    };

    // A '1' in this array means the character is white space. A '1' or
    // '2' means the character ends a name or command.
    var specialChars = [
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      1,
      1,
      0,
      1,
      1,
      0,
      0, // 0x
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0, // 1x
      1,
      0,
      0,
      0,
      0,
      2,
      0,
      0,
      2,
      2,
      0,
      0,
      0,
      0,
      0,
      2, // 2x
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      2,
      0,
      2,
      0, // 3x
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0, // 4x
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      2,
      0,
      2,
      0,
      0, // 5x
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0, // 6x
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      2,
      0,
      2,
      0,
      0, // 7x
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0, // 8x
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0, // 9x
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0, // ax
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0, // bx
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0, // cx
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0, // dx
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0, // ex
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0 // fx
    ];

    function toHexDigit(ch) {
      if (ch >= 0x30 && ch <= 0x39) {
        // '0'-'9'
        return ch & 0x0f;
      }
      if ((ch >= 0x41 && ch <= 0x46) || (ch >= 0x61 && ch <= 0x66)) {
        // 'A'-'F', 'a'-'f'
        return (ch & 0x0f) + 9;
      }
      return -1;
    }

    Lexer.prototype = {
      nextChar: function Lexer_nextChar() {
        return (this.currentChar = this.stream.getByte());
      },
      peekChar: function Lexer_peekChar() {
        return this.stream.peekByte();
      },
      getNumber: function Lexer_getNumber() {
        var ch = this.currentChar;
        var eNotation = false;
        var divideBy = 0; // different from 0 if it's a floating point value
        var sign = 1;

        if (ch === 0x2d) {
          // '-'
          sign = -1;
          ch = this.nextChar();

          if (ch === 0x2d) {
            // '-'
            // Ignore double negative (this is consistent with Adobe Reader).
            ch = this.nextChar();
          }
        } else if (ch === 0x2b) {
          // '+'
          ch = this.nextChar();
        }
        if (ch === 0x2e) {
          // '.'
          divideBy = 10;
          ch = this.nextChar();
        }
        if (ch < 0x30 || ch > 0x39) {
          // '0' - '9'
          error("Invalid number: " + String.fromCharCode(ch));
          return 0;
        }

        var baseValue = ch - 0x30; // '0'
        var powerValue = 0;
        var powerValueSign = 1;

        while ((ch = this.nextChar()) >= 0) {
          if (0x30 <= ch && ch <= 0x39) {
            // '0' - '9'
            var currentDigit = ch - 0x30; // '0'
            if (eNotation) {
              // We are after an 'e' or 'E'
              powerValue = powerValue * 10 + currentDigit;
            } else {
              if (divideBy !== 0) {
                // We are after a point
                divideBy *= 10;
              }
              baseValue = baseValue * 10 + currentDigit;
            }
          } else if (ch === 0x2e) {
            // '.'
            if (divideBy === 0) {
              divideBy = 1;
            } else {
              // A number can have only one '.'
              break;
            }
          } else if (ch === 0x2d) {
            // '-'
            // ignore minus signs in the middle of numbers to match
            // Adobe's behavior
            warn("Badly formated number");
          } else if (ch === 0x45 || ch === 0x65) {
            // 'E', 'e'
            // 'E' can be either a scientific notation or the beginning of a new
            // operator
            ch = this.peekChar();
            if (ch === 0x2b || ch === 0x2d) {
              // '+', '-'
              powerValueSign = ch === 0x2d ? -1 : 1;
              this.nextChar(); // Consume the sign character
            } else if (ch < 0x30 || ch > 0x39) {
              // '0' - '9'
              // The 'E' must be the beginning of a new operator
              break;
            }
            eNotation = true;
          } else {
            // the last character doesn't belong to us
            break;
          }
        }

        if (divideBy !== 0) {
          baseValue /= divideBy;
        }
        if (eNotation) {
          baseValue *= Math.pow(10, powerValueSign * powerValue);
        }
        return sign * baseValue;
      },
      getString: function Lexer_getString() {
        var numParen = 1;
        var done = false;
        var strBuf = this.strBuf;
        strBuf.length = 0;

        var ch = this.nextChar();
        while (true) {
          var charBuffered = false;
          switch (ch | 0) {
            case -1:
              warn("Unterminated string");
              done = true;
              break;
            case 0x28: // '('
              ++numParen;
              strBuf.push("(");
              break;
            case 0x29: // ')'
              if (--numParen === 0) {
                this.nextChar(); // consume strings ')'
                done = true;
              } else {
                strBuf.push(")");
              }
              break;
            case 0x5c: // '\\'
              ch = this.nextChar();
              switch (ch) {
                case -1:
                  warn("Unterminated string");
                  done = true;
                  break;
                case 0x6e: // 'n'
                  strBuf.push("\n");
                  break;
                case 0x72: // 'r'
                  strBuf.push("\r");
                  break;
                case 0x74: // 't'
                  strBuf.push("\t");
                  break;
                case 0x62: // 'b'
                  strBuf.push("\b");
                  break;
                case 0x66: // 'f'
                  strBuf.push("\f");
                  break;
                case 0x5c: // '\'
                case 0x28: // '('
                case 0x29: // ')'
                  strBuf.push(String.fromCharCode(ch));
                  break;
                case 0x30:
                case 0x31:
                case 0x32:
                case 0x33: // '0'-'3'
                case 0x34:
                case 0x35:
                case 0x36:
                case 0x37: // '4'-'7'
                  var x = ch & 0x0f;
                  ch = this.nextChar();
                  charBuffered = true;
                  if (ch >= 0x30 && ch <= 0x37) {
                    // '0'-'7'
                    x = (x << 3) + (ch & 0x0f);
                    ch = this.nextChar();
                    if (ch >= 0x30 && ch <= 0x37) {
                      // '0'-'7'
                      charBuffered = false;
                      x = (x << 3) + (ch & 0x0f);
                    }
                  }
                  strBuf.push(String.fromCharCode(x));
                  break;
                case 0x0d: // CR
                  if (this.peekChar() === 0x0a) {
                    // LF
                    this.nextChar();
                  }
                  break;
                case 0x0a: // LF
                  break;
                default:
                  strBuf.push(String.fromCharCode(ch));
                  break;
              }
              break;
            default:
              strBuf.push(String.fromCharCode(ch));
              break;
          }
          if (done) {
            break;
          }
          if (!charBuffered) {
            ch = this.nextChar();
          }
        }
        return strBuf.join("");
      },
      getName: function Lexer_getName() {
        var ch, previousCh;
        var strBuf = this.strBuf;
        strBuf.length = 0;
        while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) {
          if (ch === 0x23) {
            // '#'
            ch = this.nextChar();
            if (specialChars[ch]) {
              warn(
                "Lexer_getName: " +
                  "NUMBER SIGN (#) should be followed by a hexadecimal number."
              );
              strBuf.push("#");
              break;
            }
            var x = toHexDigit(ch);
            if (x !== -1) {
              previousCh = ch;
              ch = this.nextChar();
              var x2 = toHexDigit(ch);
              if (x2 === -1) {
                warn(
                  "Lexer_getName: Illegal digit (" +
                    String.fromCharCode(ch) +
                    ") in hexadecimal number."
                );
                strBuf.push("#", String.fromCharCode(previousCh));
                if (specialChars[ch]) {
                  break;