text: /* Copyright 2012 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.
   */
  
  import {
    assert,
    bytesToString,
    FormatError,
    info,
    isNum,
    StreamType,
    warn,
  } from "../shared/util.js";
  import { Cmd, Dict, EOF, isCmd, Name, Ref } from "./primitives.js";
  import {
    isWhiteSpace,
    MissingDataException,
    ParserEOFException,
  } from "./core_utils.js";
  import { Ascii85Stream } from "./ascii_85_stream.js";
  import { AsciiHexStream } from "./ascii_hex_stream.js";
  import { CCITTFaxStream } from "./ccitt_stream.js";
  import { FlateStream } from "./flate_stream.js";
  import { Jbig2Stream } from "./jbig2_stream.js";
  import { JpegStream } from "./jpeg_stream.js";
  import { JpxStream } from "./jpx_stream.js";
  import { LZWStream } from "./lzw_stream.js";
  import { NullStream } from "./stream.js";
  import { PredictorStream } from "./predictor_stream.js";
  import { RunLengthStream } from "./run_length_stream.js";
  
  const MAX_LENGTH_TO_CACHE = 1000;
  const MAX_ADLER32_LENGTH = 5552;
  
  function computeAdler32(bytes) {
    const bytesLength = bytes.length;
    if (
      typeof PDFJSDev === "undefined" ||
      PDFJSDev.test("!PRODUCTION || TESTING")
    ) {
      assert(
        bytesLength < MAX_ADLER32_LENGTH,
        'computeAdler32: Unsupported "bytes" length.'
      );
    }
    let a = 1,
      b = 0;
    for (let i = 0; i < bytesLength; ++i) {
      // No modulo required in the loop if `bytesLength < 5552`.
      a += bytes[i] & 0xff;
      b += a;
    }
    return (b % 65521 << 16) | a % 65521;
  }
  
  class Parser {
    constructor({ lexer, xref, allowStreams = false, recoveryMode = false }) {
      this.lexer = lexer;
      this.xref = xref;
      this.allowStreams = allowStreams;
      this.recoveryMode = recoveryMode;
  
      this.imageCache = Object.create(null);
      this.refill();
    }
  
    refill() {
      this.buf1 = this.lexer.getObj();
      this.buf2 = this.lexer.getObj();
    }
  
    shift() {
      if (this.buf2 instanceof Cmd && this.buf2.cmd === "ID") {
        this.buf1 = this.buf2;
        this.buf2 = null;
      } else {
        this.buf1 = this.buf2;
        this.buf2 = this.lexer.getObj();
      }
    }
  
    tryShift() {
      try {
        this.shift();
        return true;
      } catch (e) {
        if (e instanceof MissingDataException) {
          throw e;
        }
        // Upon failure, the caller should reset this.lexer.pos to a known good
        // state and call this.shift() twice to reset the buffers.
        return false;
      }
    }
  
    getObj(cipherTransform = null) {
      const buf1 = this.buf1;
      this.shift();
  
      if (buf1 instanceof Cmd) {
        switch (buf1.cmd) {
          case "BI": // inline image
            return this.makeInlineImage(cipherTransform);
          case "[": // array
            const array = [];
            while (!isCmd(this.buf1, "]") && this.buf1 !== EOF) {
              array.push(this.getObj(cipherTransform));
            }
            if (this.buf1 === EOF) {
              if (this.recoveryMode) {
                return array;
              }
              throw new ParserEOFException("End of file inside array.");
            }
            this.shift();
            return array;
          case "<<": // dictionary or stream
            const dict = new Dict(this.xref);
            while (!isCmd(this.buf1, ">>") && this.buf1 !== EOF) {
              if (!(this.buf1 instanceof Name)) {
                info("Malformed dictionary: key must be a name object");
                this.shift();
                continue;
              }
  
              const key = this.buf1.name;
              this.shift();
              if (this.buf1 === EOF) {
                break;
              }
              dict.set(key, this.getObj(cipherTransform));
            }
            if (this.buf1 === EOF) {
              if (this.recoveryMode) {
                return dict;
              }
              throw new ParserEOFException("End of file inside dictionary.");
            }
  
            // Stream objects are not allowed inside content streams or
            // object streams.
            if (isCmd(this.buf2, "stream")) {
              return this.allowStreams
                ? this.makeStream(dict, cipherTransform)
                : dict;
            }
            this.shift();
            return dict;
          default:
            // simple object
            return buf1;
        }
      }
  
      if (Number.isInteger(buf1)) {
        // indirect reference or integer
        if (Number.isInteger(this.buf1) && isCmd(this.buf2, "R")) {
          const ref = Ref.get(buf1, this.buf1);
          this.shift();
          this.shift();
          return ref;
        }
        return buf1;
      }
  
      if (typeof buf1 === "string") {
        if (cipherTransform) {
          return cipherTransform.decryptString(buf1);
        }
        return buf1;
      }
  
      // simple object
      return buf1;
    }
  
    /**
     * Find the end of the stream by searching for the /EI\s/.
     * @returns {number} The inline stream length.
     */
    findDefaultInlineStreamEnd(stream) {
      const E = 0x45,
        I = 0x49,
        SPACE = 0x20,
        LF = 0xa,
        CR = 0xd,
        NUL = 0x0;
      const lexer = this.lexer,
        startPos = stream.pos,
        n = 10;
      let state = 0,
        ch,
        maybeEIPos;
      while ((ch = stream.getByte()) !== -1) {
        if (state === 0) {
          state = ch === E ? 1 : 0;
        } else if (state === 1) {
          state = ch === I ? 2 : 0;
        } else {
          assert(state === 2, "findDefaultInlineStreamEnd - invalid state.");
          if (ch === SPACE || ch === LF || ch === CR) {
            maybeEIPos = stream.pos;
            // Let's check that the next `n` bytes are ASCII... just to be sure.
            const followingBytes = stream.peekBytes(n);
            for (let i = 0, ii = followingBytes.length; i < ii; i++) {
              ch = followingBytes[i];
              if (ch === NUL && followingBytes[i + 1] !== NUL) {
                // NUL bytes are not supposed to occur *outside* of inline
                // images, but some PDF generators violate that assumption,
                // thus breaking the EI detection heuristics used below.
                //
                // However, we can't unconditionally treat NUL bytes as "ASCII",
                // since that *could* result in inline images being truncated.
                //
                // To attempt to address this, we'll still treat any *sequence*
                // of NUL bytes as non-ASCII, but for a *single* NUL byte we'll
                // continue checking the `followingBytes` (fixes issue8823.pdf).
                continue;
              }
              if (ch !== LF && ch !== CR && (ch < SPACE || ch > 0x7f)) {
                // Not a LF, CR, SPACE or any visible ASCII character, i.e.
                // it's binary stuff. Resetting the state.
                state = 0;
                break;
              }
            }
  
            if (state !== 2) {
              continue;
            }
            // Check that the "EI" sequence isn't part of the image data, since
            // that would cause the image to be truncated (fixes issue11124.pdf).
            if (lexer.knownCommands) {
              const nextObj = lexer.peekObj();
              if (nextObj instanceof Cmd && !lexer.knownCommands[nextObj.cmd]) {
                // Not a valid command, i.e. the inline image data *itself*
                // contains an "EI" sequence. Resetting the state.
                state = 0;
              }
            } else {
              warn(
                "findDefaultInlineStreamEnd - `lexer.knownCommands` is undefined."
              );
            }
  
            if (state === 2) {
              break; // Finished!
            }
          } else {
            state = 0;
          }
        }
      }
  
      if (ch === -1) {
        warn(
          "findDefaultInlineStreamEnd: " +
            "Reached the end of the stream without finding a valid EI marker"
        );
        if (maybeEIPos) {
          warn('... trying to recover by using the last "EI" occurrence.');
          stream.skip(-(stream.pos - maybeEIPos)); // Reset the stream position.
        }
      }
  
      let endOffset = 4;
      stream.skip(-endOffset); // Set the stream position to just before "EI".
      ch = stream.peekByte();
      stream.skip(endOffset); // ... and remember to reset the stream position.
  
      // Ensure that we don't accidentally truncate the inline image, when the
      // data is immediately followed by the "EI" marker (fixes issue10388.pdf).
      if (!isWhiteSpace(ch)) {
        endOffset--;
      }
      return stream.pos - endOffset - startPos;
    }
  
    /**
     * Find the EOI (end-of-image) marker 0xFFD9 of the stream.
     * @returns {number} The inline stream length.
     */
    findDCTDecodeInlineStreamEnd(stream) {
      const startPos = stream.pos;
      let foundEOI = false,
        b,
        markerLength;
      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
          /* falls through */
          case 0xc5: // SOF5
          case 0xc6: // SOF6
          case 0xc7: // SOF7
          /* falls through */
          case 0xc9: // SOF9
          case 0xca: // SOF10
          case 0xcb: // SOF11
          /* falls through */
          case 0xcd: // SOF13
          case 0xce: // SOF14
          case 0xcf: // SOF15
          /* falls through */
          case 0xc4: // DHT
          case 0xcc: // DAC
          /* falls through */
          case 0xda: // SOS
          case 0xdb: // DQT
          case 0xdc: // DNL
          case 0xdd: // DRI
          case 0xde: // DHP
          case 0xdf: // EXP
          /* falls through */
          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
          /* falls through */
          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;
        }
      }
      const 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(stream) {
      const TILDE = 0x7e,
        GT = 0x3e;
      const startPos = stream.pos;
      let ch;
      while ((ch = stream.getByte()) !== -1) {
        if (ch === TILDE) {
          const tildePos = stream.pos;
  
          ch = stream.peekByte();
          // Handle corrupt PDF documents which contains whitespace "inside" of
          // the EOD marker (fixes issue10614.pdf).
          while (isWhiteSpace(ch)) {
            stream.skip();
            ch = stream.peekByte();
          }
          if (ch === GT) {
            stream.skip();
            break;
          }
          // Handle corrupt PDF documents which contains truncated EOD markers,
          // where the '>' character is missing (fixes issue11385.pdf).
          if (stream.pos > tildePos) {
            const maybeEI = stream.peekBytes(2);
            if (maybeEI[0] === /* E = */ 0x45 && maybeEI[1] === /* I = */ 0x49) {
              break;
            }
          }
        }
      }
      const 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(stream) {
      const GT = 0x3e;
      const startPos = stream.pos;
      let ch;
      while ((ch = stream.getByte()) !== -1) {
        if (ch === GT) {
          break;
        }
      }
      const 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(stream) {
      const E = 0x45,
        I = 0x49;
      let 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(cipherTransform) {
      const lexer = this.lexer;
      const stream = lexer.stream;
  
      // Parse dictionary.
      const dict = new Dict(this.xref);
      let dictLength;
      while (!isCmd(this.buf1, "ID") && this.buf1 !== EOF) {
        if (!(this.buf1 instanceof Name)) {
          throw new FormatError("Dictionary key must be a name object");
        }
        const key = this.buf1.name;
        this.shift();
        if (this.buf1 === EOF) {
          break;
        }
        dict.set(key, this.getObj(cipherTransform));
      }
      if (lexer.beginInlineImagePos !== -1) {
        dictLength = stream.pos - lexer.beginInlineImagePos;
      }
  
      // Extract the name of the first (i.e. the current) image filter.
      const filter = dict.get("F", "Filter");
      let filterName;
      if (filter instanceof Name) {
        filterName = filter.name;
      } else if (Array.isArray(filter)) {
        const filterZero = this.xref.fetchIfRef(filter[0]);
        if (filterZero instanceof Name) {
          filterName = filterZero.name;
        }
      }
  
      // Parse image stream.
      const startPos = stream.pos;
      let length;
      switch (filterName) {
        case "DCT":
        case "DCTDecode":
          length = this.findDCTDecodeInlineStreamEnd(stream);
          break;
        case "A85":
        case "ASCII85Decode":
          length = this.findASCII85DecodeInlineStreamEnd(stream);
          break;
        case "AHx":
        case "ASCIIHexDecode":
          length = this.findASCIIHexDecodeInlineStreamEnd(stream);
          break;
        default:
          length = this.findDefaultInlineStreamEnd(stream);
      }
      let imageStream = stream.makeSubStream(startPos, length, dict);
  
      // Cache all images below the MAX_LENGTH_TO_CACHE threshold by their
      // adler32 checksum.
      let cacheKey;
      if (length < MAX_LENGTH_TO_CACHE && dictLength < MAX_ADLER32_LENGTH) {
        const imageBytes = imageStream.getBytes();
        imageStream.reset();
  
        const initialStreamPos = stream.pos;
        // Set the stream position to the beginning of the dictionary data...
        stream.pos = lexer.beginInlineImagePos;
        // ... and fetch the bytes of the *entire* dictionary.
        const dictBytes = stream.getBytes(dictLength);
        // Finally, don't forget to reset the stream position.
        stream.pos = initialStreamPos;
  
        cacheKey = computeAdler32(imageBytes) + "_" + computeAdler32(dictBytes);
  
        const cacheEntry = this.imageCache[cacheKey];
        if (cacheEntry !== undefined) {
          this.buf2 = Cmd.get("EI");
          this.shift();
  
          cacheEntry.reset();
          return cacheEntry;
        }
      }
  
      if (cipherTransform) {
        imageStream = cipherTransform.createStream(imageStream, length);
      }
  
      imageStream = this.filter(imageStream, dict, length);
      imageStream.dict = dict;
      if (cacheKey !== undefined) {
        imageStream.cacheKey = `inline_${length}_${cacheKey}`;
        this.imageCache[cacheKey] = imageStream;
      }
  
      this.buf2 = Cmd.get("EI");
      this.shift();
  
      return imageStream;
    }
  
    _findStreamLength(startPos, signature) {
      const { stream } = this.lexer;
      stream.pos = startPos;
  
      const SCAN_BLOCK_LENGTH = 2048;
      const signatureLength = signature.length;
  
      while (stream.pos < stream.end) {
        const scanBytes = stream.peekBytes(SCAN_BLOCK_LENGTH);
        const scanLength = scanBytes.length - signatureLength;
  
        if (scanLength <= 0) {
          break;
        }
        let pos = 0;
        while (pos < scanLength) {
          let j = 0;
          while (j < signatureLength && scanBytes[pos + j] === signature[j]) {
            j++;
          }
          if (j >= signatureLength) {
            // `signature` found.
            stream.pos += pos;
            return stream.pos - startPos;
          }
          pos++;
        }
        stream.pos += scanLength;
      }
      return -1;
    }
  
    makeStream(dict, cipherTransform) {
      const lexer = this.lexer;
      let stream = lexer.stream;
  
      // Get the stream's start position.
      lexer.skipToNextLine();
      const startPos = stream.pos - 1;
  
      // Get the length.
      let length = dict.get("Length");
      if (!Number.isInteger(length)) {
        info(`Bad length "${length && length.toString()}" in stream.`);
        length = 0;
      }
  
      // Skip over the stream data.
      stream.pos = startPos + 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 command.
        const ENDSTREAM_SIGNATURE = new Uint8Array([
          0x65, 0x6e, 0x64, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6d,
        ]);
        let actualLength = this._findStreamLength(startPos, ENDSTREAM_SIGNATURE);
        if (actualLength < 0) {
          // Only allow limited truncation of the endstream signature,
          // to prevent false positives.
          const MAX_TRUNCATION = 1;
          // Check if the PDF generator included truncated endstream commands,
          // such as e.g. "endstrea" (fixes issue10004.pdf).
          for (let i = 1; i <= MAX_TRUNCATION; i++) {
            const end = ENDSTREAM_SIGNATURE.length - i;
            const TRUNCATED_SIGNATURE = ENDSTREAM_SIGNATURE.slice(0, end);
  
            const maybeLength = this._findStreamLength(
              startPos,
              TRUNCATED_SIGNATURE
            );
            if (maybeLength >= 0) {
              // Ensure that the byte immediately following the truncated
              // endstream command is a space, to prevent false positives.
              const lastByte = stream.peekBytes(end + 1)[end];
              if (!isWhiteSpace(lastByte)) {
                break;
              }
              info(
                `Found "${bytesToString(TRUNCATED_SIGNATURE)}" when ` +
                  "searching for endstream command."
              );
              actualLength = maybeLength;
              break;
            }
          }
  
          if (actualLength < 0) {
            throw new FormatError("Missing endstream command.");
          }
        }
        length = actualLength;
  
        lexer.nextChar();
        this.shift();
        this.shift();
      }
      this.shift(); // 'endstream'
  
      stream = stream.makeSubStream(startPos, length, dict);
      if (cipherTransform) {
        stream = cipherTransform.createStream(stream, length);
      }
      stream = this.filter(stream, dict, length);
      stream.dict = dict;
      return stream;
    }
  
    filter(stream, dict, length) {
      let filter = dict.get("F", "Filter");
      let params = dict.get("DP", "DecodeParms");
  
      if (filter instanceof Name) {
        if (Array.isArray(params)) {
          warn("/DecodeParms should not be an Array, when /Filter is a Name.");
        }
        return this.makeFilter(stream, filter.name, length, params);
      }
  
      let maybeLength = length;
      if (Array.isArray(filter)) {
        const filterArray = filter;
        const paramsArray = params;
        for (let i = 0, ii = filterArray.length; i < ii; ++i) {
          filter = this.xref.fetchIfRef(filterArray[i]);
          if (!(filter instanceof Name)) {
            throw new FormatError(`Bad filter name "${filter}"`);
          }
  
          params = null;
          if (Array.isArray(paramsArray) && i in paramsArray) {
            params = this.xref.fetchIfRef(paramsArray[i]);
          }
          stream = this.makeFilter(stream, filter.name, maybeLength, params);
          // After the first stream the `length` variable is invalid.
          maybeLength = null;
        }
      }
      return stream;
    }
  
    makeFilter(stream, name, maybeLength, params) {
      // Since the 'Length' entry in the stream dictionary can be completely
      // wrong, e.g. zero for non-empty streams, only skip parsing the stream
      // when we can be absolutely certain that it actually is empty.
      if (maybeLength === 0) {
        warn(`Empty "${name}" stream.`);
        return new NullStream();
      }
      const xrefStats = this.xref.stats;
  
      try {
        switch (name) {
          case "Fl":
          case "FlateDecode":
            xrefStats.addStreamType(StreamType.FLATE);
            if (params) {
              return new PredictorStream(
                new FlateStream(stream, maybeLength),
                maybeLength,
                params
              );
            }
            return new FlateStream(stream, maybeLength);
          case "LZW":
          case "LZWDecode":
            xrefStats.addStreamType(StreamType.LZW);
            let 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);
          case "DCT":
          case "DCTDecode":
            xrefStats.addStreamType(StreamType.DCT);
            return new JpegStream(stream, maybeLength, params);
          case "JPX":
          case "JPXDecode":
            xrefStats.addStreamType(StreamType.JPX);
            return new JpxStream(stream, maybeLength, params);
          case "A85":
          case "ASCII85Decode":
            xrefStats.addStreamType(StreamType.A85);
            return new Ascii85Stream(stream, maybeLength);
          case "AHx":
          case "ASCIIHexDecode":
            xrefStats.addStreamType(StreamType.AHX);
            return new AsciiHexStream(stream, maybeLength);
          case "CCF":
          case "CCITTFaxDecode":
            xrefStats.addStreamType(StreamType.CCF);
            return new CCITTFaxStream(stream, maybeLength, params);
          case "RL":
          case "RunLengthDecode":
            xrefStats.addStreamType(StreamType.RLX);
            return new RunLengthStream(stream, maybeLength);
          case "JBIG2Decode":
            xrefStats.addStreamType(StreamType.JBIG);
            return new Jbig2Stream(stream, maybeLength, params);
        }
        warn(`Filter "${name}" is not supported.`);
        return stream;
      } catch (ex) {
        if (ex instanceof MissingDataException) {
          throw ex;
        }
        warn(`Invalid stream: "${ex}"`);
        return new NullStream();
      }
    }
  }
  
  // A '1' in this array means the character is white space. A '1' or
  // '2' means the character ends a name or command.
  // prettier-ignore
  const 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 >= /* '0' = */ 0x30 && ch /* '9' = */ <= 0x39) {
      return ch & 0x0f;
    }
    if (
      (ch >= /* 'A' = */ 0x41 && ch <= /* 'F' = */ 0x46) ||
      (ch >= /* 'a' = */ 0x61 && ch <= /* 'f' = */ 0x66)
    ) {
      return (ch & 0x0f) + 9;
    }
    return -1;
  }
  
  class Lexer {
    constructor(stream, knownCommands = null) {
      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;
  
      this._hexStringNumWarn = 0;
      this.beginInlineImagePos = -1;
    }
  
    nextChar() {
      return (this.currentChar = this.stream.getByte());
    }
  
    peekChar() {
      return this.stream.peekByte();
    }
  
    getNumber() {
      let ch = this.currentChar;
      let eNotation = false;
      let divideBy = 0; // Different from 0 if it's a floating point value.
      let sign = 0;
  
      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) {
        sign = 1;
        ch = this.nextChar();
      }
      if (ch === /* LF = */ 0x0a || ch === /* CR = */ 0x0d) {
        // Ignore line-breaks (this is consistent with Adobe Reader).
        do {
          ch = this.nextChar();
        } while (ch === 0x0a || ch === 0x0d);
      }
      if (ch === /* '.' = */ 0x2e) {
        divideBy = 10;
        ch = this.nextChar();
      }
      if (ch < /* '0' = */ 0x30 || ch > /* '9' = */ 0x39) {
        if (isWhiteSpace(ch) || ch === /* EOF = */ -1) {
          // This is consistent with Adobe Reader (fixes issue9252.pdf).
          if (divideBy === 10 && sign === 0) {
            warn("Lexer.getNumber - treating a single decimal point as zero.");
            return 0;
          }
          // This is consistent with Adobe Reader (fixes bug1753983.pdf).
          if (divideBy === 0 && sign === -1) {
            warn("Lexer.getNumber - treating a single minus sign as zero.");
            return 0;
          }
        }
        throw new FormatError(
          `Invalid number: ${String.fromCharCode(ch)} (charCode ${ch})`
        );
      }
  
      sign = sign || 1;
      let baseValue = ch - 0x30; // '0'
      let powerValue = 0;
      let powerValueSign = 1;
  
      while ((ch = this.nextChar()) >= 0) {
        if (ch >= /* '0' = */ 0x30 && ch <= /* '9' = */ 0x39) {
          const 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 dot.
            break;
          }
        } else if (ch === /* '-' = */ 0x2d) {
          // Ignore minus signs in the middle of numbers to match
          // Adobe's behavior.
          warn("Badly formatted number: minus sign in the middle");
        } else if (ch === /* 'E' = */ 0x45 || ch === /* 'e' = */ 0x65) {
          // '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 < /* '0' = */ 0x30 || ch > /* '9' = */ 0x39) {
            // 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 *= 10 ** (powerValueSign * powerValue);
      }
      return sign * baseValue;
    }
  
    getString() {
      let numParen = 1;
      let done = false;
      const strBuf = this.strBuf;
      strBuf.length = 0;
  
      let ch = this.nextChar();
      while (true) {
        let 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: // '0'
              case 0x31: // '1'
              case 0x32: // '2'
              case 0x33: // '3'
              case 0x34: // '4'
              case 0x35: // '5'
              case 0x36: // '6'
              case 0x37: // '7'
                let x = ch & 0x0f;
                ch = this.nextChar();
                charBuffered = true;
                if (ch >= /* '0' = */ 0x30 && ch <= /* '7' = */ 0x37) {
                  x = (x << 3) + (ch & 0x0f);
                  ch = this.nextChar();
                  if (ch >= /* '0' = */ 0x30 && ch /* '7' = */ <= 0x37) {
                    charBuffered = false;
                    x = (x << 3) + (ch & 0x0f);
                  }
                }
                strBuf.push(String.fromCharCode(x));
                break;
              case 0x0d: // CR
                if (this.peekChar() === /* LF = */ 0x0a) {
                  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() {
      let ch, previousCh;
      const 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;
          }
          const x = toHexDigit(ch);
          if (x !== -1) {
            previousCh = ch;
            ch = this.nextChar();
            const 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;
              }
              strBuf.push(String.fromCharCode(ch));
              continue;
            }
            strBuf.push(String.fromCharCode((x << 4) | x2));
          } else {
            strBuf.push("#", String.fromCharCode(ch));
          }
        } else {
          strBuf.push(String.fromCharCode(ch));
        }
      }
      if (strBuf.length > 127) {
        warn(`Name token is longer than allowed by the spec: ${strBuf.length}`);
      }
      return Name.get(strBuf.join(""));
    }
  
    /**
     * @private
     */
    _hexStringWarn(ch) {
      const MAX_HEX_STRING_NUM_WARN = 5;
  
      if (this._hexStringNumWarn++ === MAX_HEX_STRING_NUM_WARN) {
        warn("getHexString - ignoring additional invalid characters.");
        return;
      }
      if (this._hexStringNumWarn > MAX_HEX_STRING_NUM_WARN) {
        // Limit the number of warning messages printed for a `this.getHexString`
        // invocation, since corrupt PDF documents may otherwise spam the console
        // enough to affect general performance negatively.
        return;
      }
      warn(`getHexString - ignoring invalid character: ${ch}`);
    }
  
    getHexString() {
      const strBuf = this.strBuf;
      strBuf.length = 0;
      let ch = this.currentChar;
      let isFirstHex = true;
      let firstDigit, secondDigit;
      this._hexStringNumWarn = 0;
  
      while (true) {
        if (ch < 0) {
          warn("Unterminated hex string");
          break;
        } else if (ch === /* '>' = */ 0x3e) {
          this.nextChar();
          break;
        } else if (specialChars[ch] === 1) {
          ch = this.nextChar();
          continue;
        } else {
          if (isFirstHex) {
            firstDigit = toHexDigit(ch);
            if (firstDigit === -1) {
              this._hexStringWarn(ch);
              ch = this.nextChar();
              continue;
            }
          } else {
            secondDigit = toHexDigit(ch);
            if (secondDigit === -1) {
              this._hexStringWarn(ch);
              ch = this.nextChar();
              continue;
            }
            strBuf.push(String.fromCharCode((firstDigit << 4) | secondDigit));
          }
          isFirstHex = !isFirstHex;
          ch = this.nextChar();
        }
      }
      return strBuf.join("");
    }
  
    getObj() {
      // Skip whitespace and comments.
      let comment = false;
      let ch = this.currentChar;
      while (true) {
        if (ch < 0) {
          return EOF;
        }
        if (comment) {
          if (ch === /* LF = */ 0x0a || ch === /* CR = */ 0x0d) {
            comment = false;
          }
        } else if (ch === /* '%' = */ 0x25) {
          comment = true;
        } else if (specialChars[ch] !== 1) {
          break;
        }
        ch = this.nextChar();
      }
  
      // Start reading a token.
      switch (ch | 0) {
        case 0x30: // '0'
        case 0x31: // '1'
        case 0x32: // '2'
        case 0x33: // '3'
        case 0x34: // '4'
        case 0x35: // '5'
        case 0x36: // '6'
        case 0x37: // '7'
        case 0x38: // '8'
        case 0x39: // '9'
        case 0x2b: // '+'
        case 0x2d: // '-'
        case 0x2e: // '.'
          return this.getNumber();
        case 0x28: // '('
          return this.getString();
        case 0x2f: // '/'
          return this.getName();
        // array punctuation
        case 0x5b: // '['
          this.nextChar();
          return Cmd.get("[");
        case 0x5d: // ']'
          this.nextChar();
          return Cmd.get("]");
        // hex string or dict punctuation
        case 0x3c: // '<'
          ch = this.nextChar();
          if (ch === 0x3c) {
            // dict punctuation
            this.nextChar();
            return Cmd.get("<<");
          }
          return this.getHexString();
        // dict punctuation
        case 0x3e: // '>'
          ch = this.nextChar();
          if (ch === 0x3e) {
            this.nextChar();
            return Cmd.get(">>");
          }
          return Cmd.get(">");
        case 0x7b: // '{'
          this.nextChar();
          return Cmd.get("{");
        case 0x7d: // '}'
          this.nextChar();
          return Cmd.get("}");
        case 0x29: // ')'
          // Consume the current character in order to avoid permanently hanging
          // the worker thread if `Lexer.getObj` is called from within a loop
          // containing try-catch statements, since we would otherwise attempt
          // to parse the *same* character over and over (fixes issue8061.pdf).
          this.nextChar();
          throw new FormatError(`Illegal character: ${ch}`);
      }
  
      // Start reading a command.
      let str = String.fromCharCode(ch);
      // A valid command cannot start with a non-visible ASCII character,
      // and the next character may be (the start of) a valid command.
      if (ch < 0x20 || ch > 0x7f) {
        const nextCh = this.peekChar();
        if (nextCh >= 0x20 && nextCh <= 0x7f) {
          this.nextChar();
          return Cmd.get(str);
        }
      }
      const knownCommands = this.knownCommands;
      let knownCommandFound = knownCommands && knownCommands[str] !== undefined;
      while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) {
        // Stop if a known command is found and next character does not make
        // the string a command.
        const possibleCommand = str + String.fromCharCode(ch);
        if (knownCommandFound && knownCommands[possibleCommand] === undefined) {
          break;
        }
        if (str.length === 128) {
          throw new FormatError(`Command token too long: ${str.length}`);
        }
        str = possibleCommand;
        knownCommandFound = knownCommands && knownCommands[str] !== undefined;
      }
      if (str === "true") {
        return true;
      }
      if (str === "false") {
        return false;
      }
      if (str === "null") {
        return null;
      }
  
      if (str === "BI") {
        // Keep track of the current stream position, since it's needed in order
        // to correctly cache inline images; see `Parser.makeInlineImage`.
        this.beginInlineImagePos = this.stream.pos;
      }
  
      return Cmd.get(str);
    }
  
    peekObj() {
      const streamPos = this.stream.pos,
        currentChar = this.currentChar,
        beginInlineImagePos = this.beginInlineImagePos;
  
      let nextObj;
      try {
        nextObj = this.getObj();
      } catch (ex) {
        if (ex instanceof MissingDataException) {
          throw ex;
        }
        warn(`peekObj: ${ex}`);
      }
      // Ensure that we reset *all* relevant `Lexer`-instance state.
      this.stream.pos = streamPos;
      this.currentChar = currentChar;
      this.beginInlineImagePos = beginInlineImagePos;
  
      return nextObj;
    }
  
    skipToNextLine() {
      let ch = this.currentChar;
      while (ch >= 0) {
        if (ch === /* CR = */ 0x0d) {
          ch = this.nextChar();
          if (ch === /* LF = */ 0x0a) {
            this.nextChar();
          }
          break;
        } else if (ch === /* LF = */ 0x0a) {
          this.nextChar();
          break;
        }
        ch = this.nextChar();
      }
    }
  }
  
  class Linearization {
    static create(stream) {
      function getInt(linDict, name, allowZeroValue = false) {
        const obj = linDict.get(name);
        if (Number.isInteger(obj) && (allowZeroValue ? obj >= 0 : obj > 0)) {
          return obj;
        }
        throw new Error(
          `The "${name}" parameter in the linearization ` +
            "dictionary is invalid."
        );
      }
  
      function getHints(linDict) {
        const hints = linDict.get("H");
        let hintsLength;
  
        if (
          Array.isArray(hints) &&
          ((hintsLength = hints.length) === 2 || hintsLength === 4)
        ) {
          for (let index = 0; index < hintsLength; index++) {
            const hint = hints[index];
            if (!(Number.isInteger(hint) && hint > 0)) {
              throw new Error(
                `Hint (${index}) in the linearization dictionary is invalid.`
              );
            }
          }
          return hints;
        }
        throw new Error("Hint array in the linearization dictionary is invalid.");
      }
  
      const parser = new Parser({
        lexer: new Lexer(stream),
        xref: null,
      });
      const obj1 = parser.getObj();
      const obj2 = parser.getObj();
      const obj3 = parser.getObj();
      const linDict = parser.getObj();
      let obj, length;
      if (
        !(
          Number.isInteger(obj1) &&
          Number.isInteger(obj2) &&
          isCmd(obj3, "obj") &&
          linDict instanceof Dict &&
          isNum((obj = linDict.get("Linearized"))) &&
          obj > 0
        )
      ) {
        return null; // No valid linearization dictionary found.
      } else if ((length = getInt(linDict, "L")) !== stream.length) {
        throw new Error(
          'The "L" parameter in the linearization dictionary ' +
            "does not equal the stream length."
        );
      }
      return {
        length,
        hints: getHints(linDict),
        objectNumberFirst: getInt(linDict, "O"),
        endFirst: getInt(linDict, "E"),
        numPages: getInt(linDict, "N"),
        mainXRefEntriesOffset: getInt(linDict, "T"),
        pageFirst: linDict.has("P")
          ? getInt(linDict, "P", /* allowZeroValue = */ true)
          : 0,
      };
    }
  }
  
  export { Lexer, Linearization, Parser };
  