pdfjs-dist 2.1.266 → 2.5.207

package/lib/core/parser.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2018 Mozilla Foundation
+ * Copyright 2020 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,1236 +26,1297 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.Parser = exports.Linearization = exports.Lexer = void 0;
 
-var _stream = require("./stream");
+var _stream = require("./stream.js");
 
-var _util = require("../shared/util");
+var _util = require("../shared/util.js");
 
-var _primitives = require("./primitives");
+var _primitives = require("./primitives.js");
 
-var _ccitt_stream = require("./ccitt_stream");
+var _core_utils = require("./core_utils.js");
 
-var _jbig2_stream = require("./jbig2_stream");
+var _ccitt_stream = require("./ccitt_stream.js");
 
-var _jpeg_stream = require("./jpeg_stream");
+var _jbig2_stream = require("./jbig2_stream.js");
 
-var _jpx_stream = require("./jpx_stream");
+var _jpeg_stream = require("./jpeg_stream.js");
 
-var MAX_LENGTH_TO_CACHE = 1000;
-var MAX_ADLER32_LENGTH = 5552;
+var _jpx_stream = require("./jpx_stream.js");
+
+const MAX_LENGTH_TO_CACHE = 1000;
+const MAX_ADLER32_LENGTH = 5552;
 
 function computeAdler32(bytes) {
-  var bytesLength = bytes.length;
-  var a = 1,
+  const bytesLength = bytes.length;
+  let a = 1,
       b = 0;
 
-  for (var i = 0; i < bytesLength; ++i) {
-    a += bytes[i] & 0xFF;
+  for (let i = 0; i < bytesLength; ++i) {
+    a += bytes[i] & 0xff;
     b += a;
   }
 
   return b % 65521 << 16 | a % 65521;
 }
 
-var Parser = function ParserClosure() {
-  function Parser(lexer, allowStreams, xref, recoveryMode) {
+class Parser {
+  constructor({
+    lexer,
+    xref,
+    allowStreams = false,
+    recoveryMode = false
+  }) {
     this.lexer = lexer;
-    this.allowStreams = allowStreams;
     this.xref = xref;
-    this.recoveryMode = recoveryMode || false;
+    this.allowStreams = allowStreams;
+    this.recoveryMode = recoveryMode;
     this.imageCache = Object.create(null);
     this.refill();
   }
 
-  Parser.prototype = {
-    refill: function Parser_refill() {
-      this.buf1 = this.lexer.getObj();
+  refill() {
+    this.buf1 = this.lexer.getObj();
+    this.buf2 = this.lexer.getObj();
+  }
+
+  shift() {
+    if (this.buf2 instanceof _primitives.Cmd && this.buf2.cmd === "ID") {
+      this.buf1 = this.buf2;
+      this.buf2 = null;
+    } else {
+      this.buf1 = this.buf2;
       this.buf2 = this.lexer.getObj();
-    },
-    shift: function Parser_shift() {
-      if ((0, _primitives.isCmd)(this.buf2, 'ID')) {
-        this.buf1 = this.buf2;
-        this.buf2 = null;
-      } else {
-        this.buf1 = this.buf2;
-        this.buf2 = this.lexer.getObj();
-      }
-    },
-    tryShift: function Parser_tryShift() {
-      try {
-        this.shift();
-        return true;
-      } catch (e) {
-        if (e instanceof _util.MissingDataException) {
-          throw e;
-        }
+    }
+  }
 
-        return false;
-      }
-    },
-    getObj: function Parser_getObj(cipherTransform) {
-      var buf1 = this.buf1;
+  tryShift() {
+    try {
       this.shift();
+      return true;
+    } catch (e) {
+      if (e instanceof _core_utils.MissingDataException) {
+        throw e;
+      }
+
+      return false;
+    }
+  }
 
-      if (buf1 instanceof _primitives.Cmd) {
-        switch (buf1.cmd) {
-          case 'BI':
-            return this.makeInlineImage(cipherTransform);
+  getObj(cipherTransform = null) {
+    const buf1 = this.buf1;
+    this.shift();
 
-          case '[':
-            var array = [];
+    if (buf1 instanceof _primitives.Cmd) {
+      switch (buf1.cmd) {
+        case "BI":
+          return this.makeInlineImage(cipherTransform);
 
-            while (!(0, _primitives.isCmd)(this.buf1, ']') && !(0, _primitives.isEOF)(this.buf1)) {
-              array.push(this.getObj(cipherTransform));
-            }
+        case "[":
+          const array = [];
 
-            if ((0, _primitives.isEOF)(this.buf1)) {
-              if (!this.recoveryMode) {
-                throw new _util.FormatError('End of file inside array');
-              }
+          while (!(0, _primitives.isCmd)(this.buf1, "]") && !(0, _primitives.isEOF)(this.buf1)) {
+            array.push(this.getObj(cipherTransform));
+          }
 
-              return array;
+          if ((0, _primitives.isEOF)(this.buf1)) {
+            if (!this.recoveryMode) {
+              throw new _util.FormatError("End of file inside array");
             }
 
-            this.shift();
             return array;
+          }
 
-          case '<<':
-            var dict = new _primitives.Dict(this.xref);
+          this.shift();
+          return array;
 
-            while (!(0, _primitives.isCmd)(this.buf1, '>>') && !(0, _primitives.isEOF)(this.buf1)) {
-              if (!(0, _primitives.isName)(this.buf1)) {
-                (0, _util.info)('Malformed dictionary: key must be a name object');
-                this.shift();
-                continue;
-              }
+        case "<<":
+          const dict = new _primitives.Dict(this.xref);
 
-              var key = this.buf1.name;
+          while (!(0, _primitives.isCmd)(this.buf1, ">>") && !(0, _primitives.isEOF)(this.buf1)) {
+            if (!(0, _primitives.isName)(this.buf1)) {
+              (0, _util.info)("Malformed dictionary: key must be a name object");
               this.shift();
-
-              if ((0, _primitives.isEOF)(this.buf1)) {
-                break;
-              }
-
-              dict.set(key, this.getObj(cipherTransform));
+              continue;
             }
 
-            if ((0, _primitives.isEOF)(this.buf1)) {
-              if (!this.recoveryMode) {
-                throw new _util.FormatError('End of file inside dictionary');
-              }
+            const key = this.buf1.name;
+            this.shift();
 
-              return dict;
+            if ((0, _primitives.isEOF)(this.buf1)) {
+              break;
             }
 
-            if ((0, _primitives.isCmd)(this.buf2, 'stream')) {
-              return this.allowStreams ? this.makeStream(dict, cipherTransform) : dict;
+            dict.set(key, this.getObj(cipherTransform));
+          }
+
+          if ((0, _primitives.isEOF)(this.buf1)) {
+            if (!this.recoveryMode) {
+              throw new _util.FormatError("End of file inside dictionary");
             }
 
-            this.shift();
             return dict;
+          }
 
-          default:
-            return buf1;
-        }
-      }
-
-      if (Number.isInteger(buf1)) {
-        var num = buf1;
+          if ((0, _primitives.isCmd)(this.buf2, "stream")) {
+            return this.allowStreams ? this.makeStream(dict, cipherTransform) : dict;
+          }
 
-        if (Number.isInteger(this.buf1) && (0, _primitives.isCmd)(this.buf2, 'R')) {
-          var ref = new _primitives.Ref(num, this.buf1);
-          this.shift();
           this.shift();
-          return ref;
-        }
+          return dict;
 
-        return num;
+        default:
+          return buf1;
       }
+    }
 
-      if ((0, _util.isString)(buf1)) {
-        var str = buf1;
+    if (Number.isInteger(buf1)) {
+      if (Number.isInteger(this.buf1) && (0, _primitives.isCmd)(this.buf2, "R")) {
+        const ref = _primitives.Ref.get(buf1, this.buf1);
 
-        if (cipherTransform) {
-          str = cipherTransform.decryptString(str);
-        }
+        this.shift();
+        this.shift();
+        return ref;
+      }
+
+      return buf1;
+    }
 
-        return str;
+    if (typeof buf1 === "string") {
+      if (cipherTransform) {
+        return cipherTransform.decryptString(buf1);
       }
 
       return buf1;
-    },
-    findDefaultInlineStreamEnd: function findDefaultInlineStreamEnd(stream) {
-      var E = 0x45,
+    }
+
+    return buf1;
+  }
+
+  findDefaultInlineStreamEnd(stream) {
+    const E = 0x45,
           I = 0x49,
           SPACE = 0x20,
-          LF = 0xA,
-          CR = 0xD;
-      var n = 10,
+          LF = 0xa,
+          CR = 0xd;
+    const n = 10,
           NUL = 0x0;
-      var startPos = stream.pos,
-          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 {
-          (0, _util.assert)(state === 2);
-
-          if (ch === SPACE || ch === LF || ch === CR) {
-            maybeEIPos = stream.pos;
-            var followingBytes = stream.peekBytes(n);
+    const startPos = stream.pos;
+    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 {
+        (0, _util.assert)(state === 2, "findDefaultInlineStreamEnd - invalid state.");
 
-            for (var i = 0, ii = followingBytes.length; i < ii; i++) {
-              ch = followingBytes[i];
+        if (ch === SPACE || ch === LF || ch === CR) {
+          maybeEIPos = stream.pos;
+          const followingBytes = stream.peekBytes(n);
 
-              if (ch === NUL && followingBytes[i + 1] !== NUL) {
-                continue;
-              }
+          for (let i = 0, ii = followingBytes.length; i < ii; i++) {
+            ch = followingBytes[i];
 
-              if (ch !== LF && ch !== CR && (ch < SPACE || ch > 0x7F)) {
-                state = 0;
-                break;
-              }
+            if (ch === NUL && followingBytes[i + 1] !== NUL) {
+              continue;
             }
 
-            if (state === 2) {
+            if (ch !== LF && ch !== CR && (ch < SPACE || ch > 0x7f)) {
+              state = 0;
               break;
             }
-          } else {
-            state = 0;
           }
-        }
-      }
 
-      if (ch === -1) {
-        (0, _util.warn)('findDefaultInlineStreamEnd: ' + 'Reached the end of the stream without finding a valid EI marker');
-
-        if (maybeEIPos) {
-          (0, _util.warn)('... trying to recover by using the last "EI" occurrence.');
-          stream.skip(-(stream.pos - maybeEIPos));
+          if (state === 2) {
+            break;
+          }
+        } else {
+          state = 0;
         }
       }
+    }
 
-      var endOffset = 4;
-      stream.skip(-endOffset);
-      ch = stream.peekByte();
-      stream.skip(endOffset);
+    if (ch === -1) {
+      (0, _util.warn)("findDefaultInlineStreamEnd: " + "Reached the end of the stream without finding a valid EI marker");
 
-      if (!(0, _util.isSpace)(ch)) {
-        endOffset--;
+      if (maybeEIPos) {
+        (0, _util.warn)('... trying to recover by using the last "EI" occurrence.');
+        stream.skip(-(stream.pos - maybeEIPos));
       }
+    }
 
-      return stream.pos - endOffset - startPos;
-    },
-    findDCTDecodeInlineStreamEnd: function Parser_findDCTDecodeInlineStreamEnd(stream) {
-      var startPos = stream.pos,
-          foundEOI = false,
-          b,
-          markerLength,
-          length;
-
-      while ((b = stream.getByte()) !== -1) {
-        if (b !== 0xFF) {
-          continue;
-        }
+    let endOffset = 4;
+    stream.skip(-endOffset);
+    ch = stream.peekByte();
+    stream.skip(endOffset);
 
-        switch (stream.getByte()) {
-          case 0x00:
-            break;
+    if (!(0, _core_utils.isWhiteSpace)(ch)) {
+      endOffset--;
+    }
 
-          case 0xFF:
-            stream.skip(-1);
-            break;
+    return stream.pos - endOffset - startPos;
+  }
 
-          case 0xD9:
-            foundEOI = true;
-            break;
+  findDCTDecodeInlineStreamEnd(stream) {
+    const startPos = stream.pos;
+    let foundEOI = false,
+        b,
+        markerLength;
 
-          case 0xC0:
-          case 0xC1:
-          case 0xC2:
-          case 0xC3:
-          case 0xC5:
-          case 0xC6:
-          case 0xC7:
-          case 0xC9:
-          case 0xCA:
-          case 0xCB:
-          case 0xCD:
-          case 0xCE:
-          case 0xCF:
-          case 0xC4:
-          case 0xCC:
-          case 0xDA:
-          case 0xDB:
-          case 0xDC:
-          case 0xDD:
-          case 0xDE:
-          case 0xDF:
-          case 0xE0:
-          case 0xE1:
-          case 0xE2:
-          case 0xE3:
-          case 0xE4:
-          case 0xE5:
-          case 0xE6:
-          case 0xE7:
-          case 0xE8:
-          case 0xE9:
-          case 0xEA:
-          case 0xEB:
-          case 0xEC:
-          case 0xED:
-          case 0xEE:
-          case 0xEF:
-          case 0xFE:
-            markerLength = stream.getUint16();
-
-            if (markerLength > 2) {
-              stream.skip(markerLength - 2);
-            } else {
-              stream.skip(-2);
-            }
+    while ((b = stream.getByte()) !== -1) {
+      if (b !== 0xff) {
+        continue;
+      }
 
-            break;
-        }
+      switch (stream.getByte()) {
+        case 0x00:
+          break;
 
-        if (foundEOI) {
+        case 0xff:
+          stream.skip(-1);
           break;
-        }
-      }
 
-      length = stream.pos - startPos;
+        case 0xd9:
+          foundEOI = true;
+          break;
 
-      if (b === -1) {
-        (0, _util.warn)('Inline DCTDecode image stream: ' + 'EOI marker not found, searching for /EI/ instead.');
-        stream.skip(-length);
-        return this.findDefaultInlineStreamEnd(stream);
-      }
+        case 0xc0:
+        case 0xc1:
+        case 0xc2:
+        case 0xc3:
+        case 0xc5:
+        case 0xc6:
+        case 0xc7:
+        case 0xc9:
+        case 0xca:
+        case 0xcb:
+        case 0xcd:
+        case 0xce:
+        case 0xcf:
+        case 0xc4:
+        case 0xcc:
+        case 0xda:
+        case 0xdb:
+        case 0xdc:
+        case 0xdd:
+        case 0xde:
+        case 0xdf:
+        case 0xe0:
+        case 0xe1:
+        case 0xe2:
+        case 0xe3:
+        case 0xe4:
+        case 0xe5:
+        case 0xe6:
+        case 0xe7:
+        case 0xe8:
+        case 0xe9:
+        case 0xea:
+        case 0xeb:
+        case 0xec:
+        case 0xed:
+        case 0xee:
+        case 0xef:
+        case 0xfe:
+          markerLength = stream.getUint16();
+
+          if (markerLength > 2) {
+            stream.skip(markerLength - 2);
+          } else {
+            stream.skip(-2);
+          }
 
-      this.inlineStreamSkipEI(stream);
-      return 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) {
-        (0, _util.warn)('Inline ASCII85Decode image stream: ' + 'EOD marker not found, searching for /EI/ instead.');
-        stream.skip(-length);
-        return this.findDefaultInlineStreamEnd(stream);
+      if (foundEOI) {
+        break;
       }
+    }
+
+    const length = stream.pos - startPos;
+
+    if (b === -1) {
+      (0, _util.warn)("Inline DCTDecode image stream: " + "EOI marker not found, searching for /EI/ instead.");
+      stream.skip(-length);
+      return this.findDefaultInlineStreamEnd(stream);
+    }
+
+    this.inlineStreamSkipEI(stream);
+    return length;
+  }
+
+  findASCII85DecodeInlineStreamEnd(stream) {
+    const TILDE = 0x7e,
+          GT = 0x3e;
+    const startPos = stream.pos;
+    let ch;
 
-      this.inlineStreamSkipEI(stream);
-      return length;
-    },
-    findASCIIHexDecodeInlineStreamEnd: function Parser_findASCIIHexDecodeInlineStreamEnd(stream) {
-      var GT = 0x3E;
-      var startPos = stream.pos,
-          ch,
-          length;
+    while ((ch = stream.getByte()) !== -1) {
+      if (ch === TILDE) {
+        const tildePos = stream.pos;
+        ch = stream.peekByte();
+
+        while ((0, _core_utils.isWhiteSpace)(ch)) {
+          stream.skip();
+          ch = stream.peekByte();
+        }
 
-      while ((ch = stream.getByte()) !== -1) {
         if (ch === GT) {
+          stream.skip();
           break;
         }
-      }
-
-      length = stream.pos - startPos;
 
-      if (ch === -1) {
-        (0, _util.warn)('Inline ASCIIHexDecode image stream: ' + 'EOD marker not found, searching for /EI/ instead.');
-        stream.skip(-length);
-        return this.findDefaultInlineStreamEnd(stream);
-      }
+        if (stream.pos > tildePos) {
+          const maybeEI = stream.peekBytes(2);
 
-      this.inlineStreamSkipEI(stream);
-      return length;
-    },
-    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;
+          if (maybeEI[0] === 0x45 && maybeEI[1] === 0x49) {
+            break;
+          }
         }
       }
-    },
-    makeInlineImage: function Parser_makeInlineImage(cipherTransform) {
-      var lexer = this.lexer;
-      var stream = lexer.stream;
-      var dict = new _primitives.Dict(this.xref),
-          dictLength;
-
-      while (!(0, _primitives.isCmd)(this.buf1, 'ID') && !(0, _primitives.isEOF)(this.buf1)) {
-        if (!(0, _primitives.isName)(this.buf1)) {
-          throw new _util.FormatError('Dictionary key must be a name object');
-        }
+    }
 
-        var key = this.buf1.name;
-        this.shift();
+    const length = stream.pos - startPos;
 
-        if ((0, _primitives.isEOF)(this.buf1)) {
-          break;
-        }
+    if (ch === -1) {
+      (0, _util.warn)("Inline ASCII85Decode image stream: " + "EOD marker not found, searching for /EI/ instead.");
+      stream.skip(-length);
+      return this.findDefaultInlineStreamEnd(stream);
+    }
 
-        dict.set(key, this.getObj(cipherTransform));
-      }
+    this.inlineStreamSkipEI(stream);
+    return length;
+  }
+
+  findASCIIHexDecodeInlineStreamEnd(stream) {
+    const GT = 0x3e;
+    const startPos = stream.pos;
+    let ch;
 
-      if (lexer.beginInlineImagePos !== -1) {
-        dictLength = stream.pos - lexer.beginInlineImagePos;
+    while ((ch = stream.getByte()) !== -1) {
+      if (ch === GT) {
+        break;
       }
+    }
 
-      var filter = dict.get('Filter', 'F'),
-          filterName;
+    const length = stream.pos - startPos;
 
-      if ((0, _primitives.isName)(filter)) {
-        filterName = filter.name;
-      } else if (Array.isArray(filter)) {
-        var filterZero = this.xref.fetchIfRef(filter[0]);
+    if (ch === -1) {
+      (0, _util.warn)("Inline ASCIIHexDecode image stream: " + "EOD marker not found, searching for /EI/ instead.");
+      stream.skip(-length);
+      return this.findDefaultInlineStreamEnd(stream);
+    }
 
-        if ((0, _primitives.isName)(filterZero)) {
-          filterName = filterZero.name;
-        }
+    this.inlineStreamSkipEI(stream);
+    return length;
+  }
+
+  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;
       }
+    }
+  }
 
-      var startPos = stream.pos,
-          length;
+  makeInlineImage(cipherTransform) {
+    const lexer = this.lexer;
+    const stream = lexer.stream;
+    const dict = new _primitives.Dict(this.xref);
+    let dictLength;
 
-      if (filterName === 'DCTDecode' || filterName === 'DCT') {
-        length = this.findDCTDecodeInlineStreamEnd(stream);
-      } else if (filterName === 'ASCII85Decode' || filterName === 'A85') {
-        length = this.findASCII85DecodeInlineStreamEnd(stream);
-      } else if (filterName === 'ASCIIHexDecode' || filterName === 'AHx') {
-        length = this.findASCIIHexDecodeInlineStreamEnd(stream);
-      } else {
-        length = this.findDefaultInlineStreamEnd(stream);
+    while (!(0, _primitives.isCmd)(this.buf1, "ID") && !(0, _primitives.isEOF)(this.buf1)) {
+      if (!(0, _primitives.isName)(this.buf1)) {
+        throw new _util.FormatError("Dictionary key must be a name object");
       }
 
-      var imageStream = stream.makeSubStream(startPos, length, dict);
-      var cacheKey;
-
-      if (length < MAX_LENGTH_TO_CACHE && dictLength < MAX_ADLER32_LENGTH) {
-        var imageBytes = imageStream.getBytes();
-        imageStream.reset();
-        var initialStreamPos = stream.pos;
-        stream.pos = lexer.beginInlineImagePos;
-        var dictBytes = stream.getBytes(dictLength);
-        stream.pos = initialStreamPos;
-        cacheKey = computeAdler32(imageBytes) + '_' + computeAdler32(dictBytes);
-        var cacheEntry = this.imageCache[cacheKey];
-
-        if (cacheEntry !== undefined) {
-          this.buf2 = _primitives.Cmd.get('EI');
-          this.shift();
-          cacheEntry.reset();
-          return cacheEntry;
-        }
+      const key = this.buf1.name;
+      this.shift();
+
+      if ((0, _primitives.isEOF)(this.buf1)) {
+        break;
       }
 
-      if (cipherTransform) {
-        imageStream = cipherTransform.createStream(imageStream, length);
+      dict.set(key, this.getObj(cipherTransform));
+    }
+
+    if (lexer.beginInlineImagePos !== -1) {
+      dictLength = stream.pos - lexer.beginInlineImagePos;
+    }
+
+    const filter = dict.get("Filter", "F");
+    let filterName;
+
+    if ((0, _primitives.isName)(filter)) {
+      filterName = filter.name;
+    } else if (Array.isArray(filter)) {
+      const filterZero = this.xref.fetchIfRef(filter[0]);
+
+      if ((0, _primitives.isName)(filterZero)) {
+        filterName = filterZero.name;
       }
+    }
 
-      imageStream = this.filter(imageStream, dict, length);
-      imageStream.dict = dict;
+    const startPos = stream.pos;
+    let length;
+
+    if (filterName === "DCTDecode" || filterName === "DCT") {
+      length = this.findDCTDecodeInlineStreamEnd(stream);
+    } else if (filterName === "ASCII85Decode" || filterName === "A85") {
+      length = this.findASCII85DecodeInlineStreamEnd(stream);
+    } else if (filterName === "ASCIIHexDecode" || filterName === "AHx") {
+      length = this.findASCIIHexDecodeInlineStreamEnd(stream);
+    } else {
+      length = this.findDefaultInlineStreamEnd(stream);
+    }
 
-      if (cacheKey !== undefined) {
-        imageStream.cacheKey = 'inline_' + length + '_' + cacheKey;
-        this.imageCache[cacheKey] = imageStream;
+    let imageStream = stream.makeSubStream(startPos, length, dict);
+    let cacheKey;
+
+    if (length < MAX_LENGTH_TO_CACHE && dictLength < MAX_ADLER32_LENGTH) {
+      const imageBytes = imageStream.getBytes();
+      imageStream.reset();
+      const initialStreamPos = stream.pos;
+      stream.pos = lexer.beginInlineImagePos;
+      const dictBytes = stream.getBytes(dictLength);
+      stream.pos = initialStreamPos;
+      cacheKey = computeAdler32(imageBytes) + "_" + computeAdler32(dictBytes);
+      const cacheEntry = this.imageCache[cacheKey];
+
+      if (cacheEntry !== undefined) {
+        this.buf2 = _primitives.Cmd.get("EI");
+        this.shift();
+        cacheEntry.reset();
+        return cacheEntry;
       }
+    }
 
-      this.buf2 = _primitives.Cmd.get('EI');
-      this.shift();
-      return imageStream;
-    },
-    _findStreamLength: function _findStreamLength(startPos, signature) {
-      var stream = this.lexer.stream;
-      stream.pos = startPos;
-      var SCAN_BLOCK_LENGTH = 2048;
-      var signatureLength = signature.length;
-
-      while (stream.pos < stream.end) {
-        var scanBytes = stream.peekBytes(SCAN_BLOCK_LENGTH);
-        var scanLength = scanBytes.length - signatureLength;
-
-        if (scanLength <= 0) {
-          break;
-        }
+    if (cipherTransform) {
+      imageStream = cipherTransform.createStream(imageStream, length);
+    }
 
-        var pos = 0;
+    imageStream = this.filter(imageStream, dict, length);
+    imageStream.dict = dict;
 
-        while (pos < scanLength) {
-          var j = 0;
+    if (cacheKey !== undefined) {
+      imageStream.cacheKey = `inline_${length}_${cacheKey}`;
+      this.imageCache[cacheKey] = imageStream;
+    }
 
-          while (j < signatureLength && scanBytes[pos + j] === signature[j]) {
-            j++;
-          }
+    this.buf2 = _primitives.Cmd.get("EI");
+    this.shift();
+    return imageStream;
+  }
 
-          if (j >= signatureLength) {
-            stream.pos += pos;
-            return stream.pos - startPos;
-          }
+  _findStreamLength(startPos, signature) {
+    const {
+      stream
+    } = this.lexer;
+    stream.pos = startPos;
+    const SCAN_BLOCK_LENGTH = 2048;
+    const signatureLength = signature.length;
 
-          pos++;
-        }
+    while (stream.pos < stream.end) {
+      const scanBytes = stream.peekBytes(SCAN_BLOCK_LENGTH);
+      const scanLength = scanBytes.length - signatureLength;
 
-        stream.pos += scanLength;
+      if (scanLength <= 0) {
+        break;
       }
 
-      return -1;
-    },
-    makeStream: function Parser_makeStream(dict, cipherTransform) {
-      var lexer = this.lexer;
-      var stream = lexer.stream;
-      lexer.skipToNextLine();
-      var startPos = stream.pos - 1;
-      var length = dict.get('Length');
-
-      if (!Number.isInteger(length)) {
-        (0, _util.info)('Bad ' + length + ' attribute in stream');
-        length = 0;
+      let pos = 0;
+
+      while (pos < scanLength) {
+        let j = 0;
+
+        while (j < signatureLength && scanBytes[pos + j] === signature[j]) {
+          j++;
+        }
+
+        if (j >= signatureLength) {
+          stream.pos += pos;
+          return stream.pos - startPos;
+        }
+
+        pos++;
       }
 
-      stream.pos = startPos + length;
-      lexer.nextChar();
+      stream.pos += scanLength;
+    }
 
-      if (this.tryShift() && (0, _primitives.isCmd)(this.buf2, 'endstream')) {
-        this.shift();
-      } else {
-        var ENDSTREAM_SIGNATURE = new Uint8Array([0x65, 0x6E, 0x64, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D]);
+    return -1;
+  }
 
-        var actualLength = this._findStreamLength(startPos, ENDSTREAM_SIGNATURE);
+  makeStream(dict, cipherTransform) {
+    const lexer = this.lexer;
+    let stream = lexer.stream;
+    lexer.skipToNextLine();
+    const startPos = stream.pos - 1;
+    let length = dict.get("Length");
 
-        if (actualLength < 0) {
-          var MAX_TRUNCATION = 1;
+    if (!Number.isInteger(length)) {
+      (0, _util.info)(`Bad length "${length}" in stream`);
+      length = 0;
+    }
+
+    stream.pos = startPos + length;
+    lexer.nextChar();
 
-          for (var i = 1; i <= MAX_TRUNCATION; i++) {
-            var end = ENDSTREAM_SIGNATURE.length - i;
-            var TRUNCATED_SIGNATURE = ENDSTREAM_SIGNATURE.slice(0, end);
+    if (this.tryShift() && (0, _primitives.isCmd)(this.buf2, "endstream")) {
+      this.shift();
+    } else {
+      const ENDSTREAM_SIGNATURE = new Uint8Array([0x65, 0x6E, 0x64, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D]);
 
-            var maybeLength = this._findStreamLength(startPos, TRUNCATED_SIGNATURE);
+      let actualLength = this._findStreamLength(startPos, ENDSTREAM_SIGNATURE);
 
-            if (maybeLength >= 0) {
-              var lastByte = stream.peekBytes(end + 1)[end];
+      if (actualLength < 0) {
+        const MAX_TRUNCATION = 1;
 
-              if (!(0, _util.isSpace)(lastByte)) {
-                break;
-              }
+        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) {
+            const lastByte = stream.peekBytes(end + 1)[end];
 
-              (0, _util.info)("Found \"".concat((0, _util.bytesToString)(TRUNCATED_SIGNATURE), "\" when ") + 'searching for endstream command.');
-              actualLength = maybeLength;
+            if (!(0, _core_utils.isWhiteSpace)(lastByte)) {
               break;
             }
-          }
 
-          if (actualLength < 0) {
-            throw new _util.FormatError('Missing endstream command.');
+            (0, _util.info)(`Found "${(0, _util.bytesToString)(TRUNCATED_SIGNATURE)}" when ` + "searching for endstream command.");
+            actualLength = maybeLength;
+            break;
           }
         }
 
-        length = actualLength;
-        lexer.nextChar();
-        this.shift();
-        this.shift();
+        if (actualLength < 0) {
+          throw new _util.FormatError("Missing endstream command.");
+        }
       }
 
+      length = actualLength;
+      lexer.nextChar();
       this.shift();
-      stream = stream.makeSubStream(startPos, length, dict);
+      this.shift();
+    }
 
-      if (cipherTransform) {
-        stream = cipherTransform.createStream(stream, length);
-      }
+    this.shift();
+    stream = stream.makeSubStream(startPos, length, dict);
 
-      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 ((0, _primitives.isName)(filter)) {
-        if (Array.isArray(params)) {
-          (0, _util.warn)('/DecodeParms should not contain an Array, ' + 'when /Filter contains a Name.');
-        }
+    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("Filter", "F");
+    let params = dict.get("DecodeParms", "DP");
 
-        return this.makeFilter(stream, filter.name, length, params);
+    if ((0, _primitives.isName)(filter)) {
+      if (Array.isArray(params)) {
+        (0, _util.warn)("/DecodeParms should not contain an Array, " + "when /Filter contains a Name.");
       }
 
-      var maybeLength = length;
+      return this.makeFilter(stream, filter.name, length, params);
+    }
 
-      if (Array.isArray(filter)) {
-        var filterArray = filter;
-        var paramsArray = params;
+    let maybeLength = length;
 
-        for (var i = 0, ii = filterArray.length; i < ii; ++i) {
-          filter = this.xref.fetchIfRef(filterArray[i]);
+    if (Array.isArray(filter)) {
+      const filterArray = filter;
+      const paramsArray = params;
 
-          if (!(0, _primitives.isName)(filter)) {
-            throw new _util.FormatError('Bad filter name: ' + filter);
-          }
+      for (let i = 0, ii = filterArray.length; i < ii; ++i) {
+        filter = this.xref.fetchIfRef(filterArray[i]);
 
-          params = null;
+        if (!(0, _primitives.isName)(filter)) {
+          throw new _util.FormatError(`Bad filter name "${filter}"`);
+        }
 
-          if (Array.isArray(paramsArray) && i in paramsArray) {
-            params = this.xref.fetchIfRef(paramsArray[i]);
-          }
+        params = null;
 
-          stream = this.makeFilter(stream, filter.name, maybeLength, params);
-          maybeLength = null;
+        if (Array.isArray(paramsArray) && i in paramsArray) {
+          params = this.xref.fetchIfRef(paramsArray[i]);
         }
-      }
 
-      return stream;
-    },
-    makeFilter: function Parser_makeFilter(stream, name, maybeLength, params) {
-      if (maybeLength === 0) {
-        (0, _util.warn)('Empty "' + name + '" stream.');
-        return new _stream.NullStream();
+        stream = this.makeFilter(stream, filter.name, maybeLength, params);
+        maybeLength = null;
       }
+    }
 
-      try {
-        var xrefStreamStats = this.xref.stats.streamTypes;
+    return stream;
+  }
+
+  makeFilter(stream, name, maybeLength, params) {
+    if (maybeLength === 0) {
+      (0, _util.warn)(`Empty "${name}" stream.`);
+      return new _stream.NullStream();
+    }
 
-        if (name === 'FlateDecode' || name === 'Fl') {
-          xrefStreamStats[_util.StreamType.FLATE] = true;
+    try {
+      const xrefStreamStats = this.xref.stats.streamTypes;
 
-          if (params) {
-            return new _stream.PredictorStream(new _stream.FlateStream(stream, maybeLength), maybeLength, params);
-          }
+      if (name === "FlateDecode" || name === "Fl") {
+        xrefStreamStats[_util.StreamType.FLATE] = true;
 
-          return new _stream.FlateStream(stream, maybeLength);
+        if (params) {
+          return new _stream.PredictorStream(new _stream.FlateStream(stream, maybeLength), maybeLength, params);
         }
 
-        if (name === 'LZWDecode' || name === 'LZW') {
-          xrefStreamStats[_util.StreamType.LZW] = true;
-          var earlyChange = 1;
+        return new _stream.FlateStream(stream, maybeLength);
+      }
 
-          if (params) {
-            if (params.has('EarlyChange')) {
-              earlyChange = params.get('EarlyChange');
-            }
+      if (name === "LZWDecode" || name === "LZW") {
+        xrefStreamStats[_util.StreamType.LZW] = true;
+        let earlyChange = 1;
 
-            return new _stream.PredictorStream(new _stream.LZWStream(stream, maybeLength, earlyChange), maybeLength, params);
+        if (params) {
+          if (params.has("EarlyChange")) {
+            earlyChange = params.get("EarlyChange");
           }
 
-          return new _stream.LZWStream(stream, maybeLength, earlyChange);
+          return new _stream.PredictorStream(new _stream.LZWStream(stream, maybeLength, earlyChange), maybeLength, params);
         }
 
-        if (name === 'DCTDecode' || name === 'DCT') {
-          xrefStreamStats[_util.StreamType.DCT] = true;
-          return new _jpeg_stream.JpegStream(stream, maybeLength, stream.dict, params);
-        }
+        return new _stream.LZWStream(stream, maybeLength, earlyChange);
+      }
 
-        if (name === 'JPXDecode' || name === 'JPX') {
-          xrefStreamStats[_util.StreamType.JPX] = true;
-          return new _jpx_stream.JpxStream(stream, maybeLength, stream.dict, params);
-        }
+      if (name === "DCTDecode" || name === "DCT") {
+        xrefStreamStats[_util.StreamType.DCT] = true;
+        return new _jpeg_stream.JpegStream(stream, maybeLength, stream.dict, params);
+      }
 
-        if (name === 'ASCII85Decode' || name === 'A85') {
-          xrefStreamStats[_util.StreamType.A85] = true;
-          return new _stream.Ascii85Stream(stream, maybeLength);
-        }
+      if (name === "JPXDecode" || name === "JPX") {
+        xrefStreamStats[_util.StreamType.JPX] = true;
+        return new _jpx_stream.JpxStream(stream, maybeLength, stream.dict, params);
+      }
 
-        if (name === 'ASCIIHexDecode' || name === 'AHx') {
-          xrefStreamStats[_util.StreamType.AHX] = true;
-          return new _stream.AsciiHexStream(stream, maybeLength);
-        }
+      if (name === "ASCII85Decode" || name === "A85") {
+        xrefStreamStats[_util.StreamType.A85] = true;
+        return new _stream.Ascii85Stream(stream, maybeLength);
+      }
 
-        if (name === 'CCITTFaxDecode' || name === 'CCF') {
-          xrefStreamStats[_util.StreamType.CCF] = true;
-          return new _ccitt_stream.CCITTFaxStream(stream, maybeLength, params);
-        }
+      if (name === "ASCIIHexDecode" || name === "AHx") {
+        xrefStreamStats[_util.StreamType.AHX] = true;
+        return new _stream.AsciiHexStream(stream, maybeLength);
+      }
 
-        if (name === 'RunLengthDecode' || name === 'RL') {
-          xrefStreamStats[_util.StreamType.RL] = true;
-          return new _stream.RunLengthStream(stream, maybeLength);
-        }
+      if (name === "CCITTFaxDecode" || name === "CCF") {
+        xrefStreamStats[_util.StreamType.CCF] = true;
+        return new _ccitt_stream.CCITTFaxStream(stream, maybeLength, params);
+      }
 
-        if (name === 'JBIG2Decode') {
-          xrefStreamStats[_util.StreamType.JBIG] = true;
-          return new _jbig2_stream.Jbig2Stream(stream, maybeLength, stream.dict, params);
-        }
+      if (name === "RunLengthDecode" || name === "RL") {
+        xrefStreamStats[_util.StreamType.RLX] = true;
+        return new _stream.RunLengthStream(stream, maybeLength);
+      }
 
-        (0, _util.warn)('filter "' + name + '" not supported yet');
-        return stream;
-      } catch (ex) {
-        if (ex instanceof _util.MissingDataException) {
-          throw ex;
-        }
+      if (name === "JBIG2Decode") {
+        xrefStreamStats[_util.StreamType.JBIG] = true;
+        return new _jbig2_stream.Jbig2Stream(stream, maybeLength, stream.dict, params);
+      }
 
-        (0, _util.warn)('Invalid stream: \"' + ex + '\"');
-        return new _stream.NullStream();
+      (0, _util.warn)(`Filter "${name}" is not supported.`);
+      return stream;
+    } catch (ex) {
+      if (ex instanceof _core_utils.MissingDataException) {
+        throw ex;
       }
+
+      (0, _util.warn)(`Invalid stream: "${ex}"`);
+      return new _stream.NullStream();
     }
-  };
-  return Parser;
-}();
+  }
+
+}
 
 exports.Parser = Parser;
+const specialChars = [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 2, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
 
-var Lexer = function LexerClosure() {
-  function Lexer(stream, knownCommands) {
+function toHexDigit(ch) {
+  if (ch >= 0x30 && ch <= 0x39) {
+    return ch & 0x0f;
+  }
+
+  if (ch >= 0x41 && ch <= 0x46 || ch >= 0x61 && ch <= 0x66) {
+    return (ch & 0x0f) + 9;
+  }
+
+  return -1;
+}
+
+class Lexer {
+  constructor(stream, knownCommands = null) {
     this.stream = stream;
     this.nextChar();
     this.strBuf = [];
     this.knownCommands = knownCommands;
+    this._hexStringNumWarn = 0;
     this.beginInlineImagePos = -1;
   }
 
-  var specialChars = [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 2, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-
-  function toHexDigit(ch) {
-    if (ch >= 0x30 && ch <= 0x39) {
-      return ch & 0x0F;
-    }
-
-    if (ch >= 0x41 && ch <= 0x46 || ch >= 0x61 && ch <= 0x66) {
-      return (ch & 0x0F) + 9;
-    }
+  nextChar() {
+    return this.currentChar = this.stream.getByte();
+  }
 
-    return -1;
+  peekChar() {
+    return this.stream.peekByte();
   }
 
-  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;
-      var sign = 0;
-
-      if (ch === 0x2D) {
-        sign = -1;
-        ch = this.nextChar();
+  getNumber() {
+    let ch = this.currentChar;
+    let eNotation = false;
+    let divideBy = 0;
+    let sign = 0;
 
-        if (ch === 0x2D) {
-          ch = this.nextChar();
-        }
-      } else if (ch === 0x2B) {
-        sign = 1;
-        ch = this.nextChar();
-      }
+    if (ch === 0x2d) {
+      sign = -1;
+      ch = this.nextChar();
 
-      if (ch === 0x0A || ch === 0x0D) {
-        do {
-          ch = this.nextChar();
-        } while (ch === 0x0A || ch === 0x0D);
+      if (ch === 0x2d) {
+        ch = this.nextChar();
       }
+    } else if (ch === 0x2b) {
+      sign = 1;
+      ch = this.nextChar();
+    }
 
-      if (ch === 0x2E) {
-        divideBy = 10;
+    if (ch === 0x0a || ch === 0x0d) {
+      do {
         ch = this.nextChar();
-      }
+      } while (ch === 0x0a || ch === 0x0d);
+    }
 
-      if (ch < 0x30 || ch > 0x39) {
-        if (divideBy === 10 && sign === 0 && ((0, _util.isSpace)(ch) || ch === -1)) {
-          (0, _util.warn)('Lexer.getNumber - treating a single decimal point as zero.');
-          return 0;
-        }
+    if (ch === 0x2e) {
+      divideBy = 10;
+      ch = this.nextChar();
+    }
 
-        throw new _util.FormatError("Invalid number: ".concat(String.fromCharCode(ch), " (charCode ").concat(ch, ")"));
+    if (ch < 0x30 || ch > 0x39) {
+      if (divideBy === 10 && sign === 0 && ((0, _core_utils.isWhiteSpace)(ch) || ch === -1)) {
+        (0, _util.warn)("Lexer.getNumber - treating a single decimal point as zero.");
+        return 0;
       }
 
-      sign = sign || 1;
-      var baseValue = ch - 0x30;
-      var powerValue = 0;
-      var powerValueSign = 1;
-
-      while ((ch = this.nextChar()) >= 0) {
-        if (0x30 <= ch && ch <= 0x39) {
-          var currentDigit = ch - 0x30;
+      throw new _util.FormatError(`Invalid number: ${String.fromCharCode(ch)} (charCode ${ch})`);
+    }
 
-          if (eNotation) {
-            powerValue = powerValue * 10 + currentDigit;
-          } else {
-            if (divideBy !== 0) {
-              divideBy *= 10;
-            }
+    sign = sign || 1;
+    let baseValue = ch - 0x30;
+    let powerValue = 0;
+    let powerValueSign = 1;
 
-            baseValue = baseValue * 10 + currentDigit;
-          }
-        } else if (ch === 0x2E) {
-          if (divideBy === 0) {
-            divideBy = 1;
-          } else {
-            break;
-          }
-        } else if (ch === 0x2D) {
-          (0, _util.warn)('Badly formatted number');
-        } else if (ch === 0x45 || ch === 0x65) {
-          ch = this.peekChar();
+    while ((ch = this.nextChar()) >= 0) {
+      if (ch >= 0x30 && ch <= 0x39) {
+        const currentDigit = ch - 0x30;
 
-          if (ch === 0x2B || ch === 0x2D) {
-            powerValueSign = ch === 0x2D ? -1 : 1;
-            this.nextChar();
-          } else if (ch < 0x30 || ch > 0x39) {
-            break;
+        if (eNotation) {
+          powerValue = powerValue * 10 + currentDigit;
+        } else {
+          if (divideBy !== 0) {
+            divideBy *= 10;
           }
 
-          eNotation = true;
+          baseValue = baseValue * 10 + currentDigit;
+        }
+      } else if (ch === 0x2e) {
+        if (divideBy === 0) {
+          divideBy = 1;
         } else {
           break;
         }
-      }
+      } else if (ch === 0x2d) {
+        (0, _util.warn)("Badly formatted number: minus sign in the middle");
+      } else if (ch === 0x45 || ch === 0x65) {
+        ch = this.peekChar();
 
-      if (divideBy !== 0) {
-        baseValue /= divideBy;
-      }
+        if (ch === 0x2b || ch === 0x2d) {
+          powerValueSign = ch === 0x2d ? -1 : 1;
+          this.nextChar();
+        } else if (ch < 0x30 || ch > 0x39) {
+          break;
+        }
 
-      if (eNotation) {
-        baseValue *= Math.pow(10, powerValueSign * powerValue);
+        eNotation = true;
+      } else {
+        break;
       }
+    }
 
-      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:
-            (0, _util.warn)('Unterminated string');
-            done = true;
-            break;
+    if (divideBy !== 0) {
+      baseValue /= divideBy;
+    }
 
-          case 0x28:
-            ++numParen;
-            strBuf.push('(');
-            break;
+    if (eNotation) {
+      baseValue *= 10 ** (powerValueSign * powerValue);
+    }
 
-          case 0x29:
-            if (--numParen === 0) {
-              this.nextChar();
-              done = true;
-            } else {
-              strBuf.push(')');
-            }
+    return sign * baseValue;
+  }
 
-            break;
+  getString() {
+    let numParen = 1;
+    let done = false;
+    const strBuf = this.strBuf;
+    strBuf.length = 0;
+    let ch = this.nextChar();
 
-          case 0x5C:
-            ch = this.nextChar();
+    while (true) {
+      let charBuffered = false;
 
-            switch (ch) {
-              case -1:
-                (0, _util.warn)('Unterminated string');
-                done = true;
-                break;
-
-              case 0x6E:
-                strBuf.push('\n');
-                break;
-
-              case 0x72:
-                strBuf.push('\r');
-                break;
-
-              case 0x74:
-                strBuf.push('\t');
-                break;
-
-              case 0x62:
-                strBuf.push('\b');
-                break;
-
-              case 0x66:
-                strBuf.push('\f');
-                break;
-
-              case 0x5C:
-              case 0x28:
-              case 0x29:
-                strBuf.push(String.fromCharCode(ch));
-                break;
-
-              case 0x30:
-              case 0x31:
-              case 0x32:
-              case 0x33:
-              case 0x34:
-              case 0x35:
-              case 0x36:
-              case 0x37:
-                var x = ch & 0x0F;
-                ch = this.nextChar();
-                charBuffered = true;
+      switch (ch | 0) {
+        case -1:
+          (0, _util.warn)("Unterminated string");
+          done = true;
+          break;
 
-                if (ch >= 0x30 && ch <= 0x37) {
-                  x = (x << 3) + (ch & 0x0F);
-                  ch = this.nextChar();
+        case 0x28:
+          ++numParen;
+          strBuf.push("(");
+          break;
 
-                  if (ch >= 0x30 && ch <= 0x37) {
-                    charBuffered = false;
-                    x = (x << 3) + (ch & 0x0F);
-                  }
-                }
+        case 0x29:
+          if (--numParen === 0) {
+            this.nextChar();
+            done = true;
+          } else {
+            strBuf.push(")");
+          }
 
-                strBuf.push(String.fromCharCode(x));
-                break;
+          break;
 
-              case 0x0D:
-                if (this.peekChar() === 0x0A) {
-                  this.nextChar();
-                }
+        case 0x5c:
+          ch = this.nextChar();
 
-                break;
+          switch (ch) {
+            case -1:
+              (0, _util.warn)("Unterminated string");
+              done = true;
+              break;
 
-              case 0x0A:
-                break;
+            case 0x6e:
+              strBuf.push("\n");
+              break;
 
-              default:
-                strBuf.push(String.fromCharCode(ch));
-                break;
-            }
+            case 0x72:
+              strBuf.push("\r");
+              break;
 
-            break;
+            case 0x74:
+              strBuf.push("\t");
+              break;
 
-          default:
-            strBuf.push(String.fromCharCode(ch));
-            break;
-        }
+            case 0x62:
+              strBuf.push("\b");
+              break;
 
-        if (done) {
-          break;
-        }
+            case 0x66:
+              strBuf.push("\f");
+              break;
 
-        if (!charBuffered) {
-          ch = this.nextChar();
-        }
-      }
+            case 0x5c:
+            case 0x28:
+            case 0x29:
+              strBuf.push(String.fromCharCode(ch));
+              break;
 
-      return strBuf.join('');
-    },
-    getName: function Lexer_getName() {
-      var ch, previousCh;
-      var strBuf = this.strBuf;
-      strBuf.length = 0;
+            case 0x30:
+            case 0x31:
+            case 0x32:
+            case 0x33:
+            case 0x34:
+            case 0x35:
+            case 0x36:
+            case 0x37:
+              let x = ch & 0x0f;
+              ch = this.nextChar();
+              charBuffered = true;
 
-      while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) {
-        if (ch === 0x23) {
-          ch = this.nextChar();
+              if (ch >= 0x30 && ch <= 0x37) {
+                x = (x << 3) + (ch & 0x0f);
+                ch = this.nextChar();
 
-          if (specialChars[ch]) {
-            (0, _util.warn)('Lexer_getName: ' + 'NUMBER SIGN (#) should be followed by a hexadecimal number.');
-            strBuf.push('#');
-            break;
-          }
+                if (ch >= 0x30 && ch <= 0x37) {
+                  charBuffered = false;
+                  x = (x << 3) + (ch & 0x0f);
+                }
+              }
 
-          var x = toHexDigit(ch);
+              strBuf.push(String.fromCharCode(x));
+              break;
 
-          if (x !== -1) {
-            previousCh = ch;
-            ch = this.nextChar();
-            var x2 = toHexDigit(ch);
+            case 0x0d:
+              if (this.peekChar() === 0x0a) {
+                this.nextChar();
+              }
 
-            if (x2 === -1) {
-              (0, _util.warn)('Lexer_getName: Illegal digit (' + String.fromCharCode(ch) + ') in hexadecimal number.');
-              strBuf.push('#', String.fromCharCode(previousCh));
+              break;
 
-              if (specialChars[ch]) {
-                break;
-              }
+            case 0x0a:
+              break;
 
+            default:
               strBuf.push(String.fromCharCode(ch));
-              continue;
-            }
-
-            strBuf.push(String.fromCharCode(x << 4 | x2));
-          } else {
-            strBuf.push('#', String.fromCharCode(ch));
+              break;
           }
-        } else {
+
+          break;
+
+        default:
           strBuf.push(String.fromCharCode(ch));
-        }
+          break;
       }
 
-      if (strBuf.length > 127) {
-        (0, _util.warn)('name token is longer than allowed by the spec: ' + strBuf.length);
+      if (done) {
+        break;
       }
 
-      return _primitives.Name.get(strBuf.join(''));
-    },
-    getHexString: function Lexer_getHexString() {
-      var strBuf = this.strBuf;
-      strBuf.length = 0;
-      var ch = this.currentChar;
-      var isFirstHex = true;
-      var firstDigit;
-      var secondDigit;
-
-      while (true) {
-        if (ch < 0) {
-          (0, _util.warn)('Unterminated hex string');
-          break;
-        } else if (ch === 0x3E) {
-          this.nextChar();
+      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]) {
+          (0, _util.warn)("Lexer_getName: " + "NUMBER SIGN (#) should be followed by a hexadecimal number.");
+          strBuf.push("#");
           break;
-        } else if (specialChars[ch] === 1) {
+        }
+
+        const x = toHexDigit(ch);
+
+        if (x !== -1) {
+          previousCh = ch;
           ch = this.nextChar();
-          continue;
-        } else {
-          if (isFirstHex) {
-            firstDigit = toHexDigit(ch);
+          const x2 = toHexDigit(ch);
 
-            if (firstDigit === -1) {
-              (0, _util.warn)('Ignoring invalid character "' + ch + '" in hex string');
-              ch = this.nextChar();
-              continue;
-            }
-          } else {
-            secondDigit = toHexDigit(ch);
+          if (x2 === -1) {
+            (0, _util.warn)(`Lexer_getName: Illegal digit (${String.fromCharCode(ch)}) ` + "in hexadecimal number.");
+            strBuf.push("#", String.fromCharCode(previousCh));
 
-            if (secondDigit === -1) {
-              (0, _util.warn)('Ignoring invalid character "' + ch + '" in hex string');
-              ch = this.nextChar();
-              continue;
+            if (specialChars[ch]) {
+              break;
             }
 
-            strBuf.push(String.fromCharCode(firstDigit << 4 | secondDigit));
+            strBuf.push(String.fromCharCode(ch));
+            continue;
           }
 
-          isFirstHex = !isFirstHex;
-          ch = this.nextChar();
+          strBuf.push(String.fromCharCode(x << 4 | x2));
+        } else {
+          strBuf.push("#", String.fromCharCode(ch));
         }
+      } else {
+        strBuf.push(String.fromCharCode(ch));
       }
+    }
 
-      return strBuf.join('');
-    },
-    getObj: function Lexer_getObj() {
-      var comment = false;
-      var ch = this.currentChar;
+    if (strBuf.length > 127) {
+      (0, _util.warn)(`Name token is longer than allowed by the spec: ${strBuf.length}`);
+    }
 
-      while (true) {
-        if (ch < 0) {
-          return _primitives.EOF;
-        }
+    return _primitives.Name.get(strBuf.join(""));
+  }
 
-        if (comment) {
-          if (ch === 0x0A || ch === 0x0D) {
-            comment = false;
-          }
-        } else if (ch === 0x25) {
-          comment = true;
-        } else if (specialChars[ch] !== 1) {
-          break;
-        }
+  _hexStringWarn(ch) {
+    const MAX_HEX_STRING_NUM_WARN = 5;
 
-        ch = this.nextChar();
-      }
+    if (this._hexStringNumWarn++ === MAX_HEX_STRING_NUM_WARN) {
+      (0, _util.warn)("getHexString - ignoring additional invalid characters.");
+      return;
+    }
 
-      switch (ch | 0) {
-        case 0x30:
-        case 0x31:
-        case 0x32:
-        case 0x33:
-        case 0x34:
-        case 0x35:
-        case 0x36:
-        case 0x37:
-        case 0x38:
-        case 0x39:
-        case 0x2B:
-        case 0x2D:
-        case 0x2E:
-          return this.getNumber();
+    if (this._hexStringNumWarn > MAX_HEX_STRING_NUM_WARN) {
+      return;
+    }
 
-        case 0x28:
-          return this.getString();
+    (0, _util.warn)(`getHexString - ignoring invalid character: ${ch}`);
+  }
 
-        case 0x2F:
-          return this.getName();
+  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) {
+        (0, _util.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);
 
-        case 0x5B:
-          this.nextChar();
-          return _primitives.Cmd.get('[');
+          if (firstDigit === -1) {
+            this._hexStringWarn(ch);
 
-        case 0x5D:
-          this.nextChar();
-          return _primitives.Cmd.get(']');
+            ch = this.nextChar();
+            continue;
+          }
+        } else {
+          secondDigit = toHexDigit(ch);
 
-        case 0x3C:
-          ch = this.nextChar();
+          if (secondDigit === -1) {
+            this._hexStringWarn(ch);
 
-          if (ch === 0x3C) {
-            this.nextChar();
-            return _primitives.Cmd.get('<<');
+            ch = this.nextChar();
+            continue;
           }
 
-          return this.getHexString();
-
-        case 0x3E:
-          ch = this.nextChar();
+          strBuf.push(String.fromCharCode(firstDigit << 4 | secondDigit));
+        }
 
-          if (ch === 0x3E) {
-            this.nextChar();
-            return _primitives.Cmd.get('>>');
-          }
+        isFirstHex = !isFirstHex;
+        ch = this.nextChar();
+      }
+    }
 
-          return _primitives.Cmd.get('>');
+    return strBuf.join("");
+  }
 
-        case 0x7B:
-          this.nextChar();
-          return _primitives.Cmd.get('{');
+  getObj() {
+    let comment = false;
+    let ch = this.currentChar;
 
-        case 0x7D:
-          this.nextChar();
-          return _primitives.Cmd.get('}');
+    while (true) {
+      if (ch < 0) {
+        return _primitives.EOF;
+      }
 
-        case 0x29:
-          this.nextChar();
-          throw new _util.FormatError("Illegal character: ".concat(ch));
+      if (comment) {
+        if (ch === 0x0a || ch === 0x0d) {
+          comment = false;
+        }
+      } else if (ch === 0x25) {
+        comment = true;
+      } else if (specialChars[ch] !== 1) {
+        break;
       }
 
-      var str = String.fromCharCode(ch);
-      var knownCommands = this.knownCommands;
-      var knownCommandFound = knownCommands && knownCommands[str] !== undefined;
+      ch = this.nextChar();
+    }
 
-      while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) {
-        var possibleCommand = str + String.fromCharCode(ch);
+    switch (ch | 0) {
+      case 0x30:
+      case 0x31:
+      case 0x32:
+      case 0x33:
+      case 0x34:
+      case 0x35:
+      case 0x36:
+      case 0x37:
+      case 0x38:
+      case 0x39:
+      case 0x2b:
+      case 0x2d:
+      case 0x2e:
+        return this.getNumber();
+
+      case 0x28:
+        return this.getString();
+
+      case 0x2f:
+        return this.getName();
+
+      case 0x5b:
+        this.nextChar();
+        return _primitives.Cmd.get("[");
+
+      case 0x5d:
+        this.nextChar();
+        return _primitives.Cmd.get("]");
+
+      case 0x3c:
+        ch = this.nextChar();
 
-        if (knownCommandFound && knownCommands[possibleCommand] === undefined) {
-          break;
+        if (ch === 0x3c) {
+          this.nextChar();
+          return _primitives.Cmd.get("<<");
         }
 
-        if (str.length === 128) {
-          throw new _util.FormatError("Command token too long: ".concat(str.length));
+        return this.getHexString();
+
+      case 0x3e:
+        ch = this.nextChar();
+
+        if (ch === 0x3e) {
+          this.nextChar();
+          return _primitives.Cmd.get(">>");
         }
 
-        str = possibleCommand;
-        knownCommandFound = knownCommands && knownCommands[str] !== undefined;
-      }
+        return _primitives.Cmd.get(">");
 
-      if (str === 'true') {
-        return true;
-      }
+      case 0x7b:
+        this.nextChar();
+        return _primitives.Cmd.get("{");
 
-      if (str === 'false') {
-        return false;
-      }
+      case 0x7d:
+        this.nextChar();
+        return _primitives.Cmd.get("}");
+
+      case 0x29:
+        this.nextChar();
+        throw new _util.FormatError(`Illegal character: ${ch}`);
+    }
+
+    let str = String.fromCharCode(ch);
+    const knownCommands = this.knownCommands;
+    let knownCommandFound = knownCommands && knownCommands[str] !== undefined;
 
-      if (str === 'null') {
-        return null;
+    while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) {
+      const possibleCommand = str + String.fromCharCode(ch);
+
+      if (knownCommandFound && knownCommands[possibleCommand] === undefined) {
+        break;
       }
 
-      if (str === 'BI') {
-        this.beginInlineImagePos = this.stream.pos;
+      if (str.length === 128) {
+        throw new _util.FormatError(`Command token too long: ${str.length}`);
       }
 
-      return _primitives.Cmd.get(str);
-    },
-    skipToNextLine: function Lexer_skipToNextLine() {
-      var ch = this.currentChar;
+      str = possibleCommand;
+      knownCommandFound = knownCommands && knownCommands[str] !== undefined;
+    }
 
-      while (ch >= 0) {
-        if (ch === 0x0D) {
-          ch = this.nextChar();
+    if (str === "true") {
+      return true;
+    }
 
-          if (ch === 0x0A) {
-            this.nextChar();
-          }
+    if (str === "false") {
+      return false;
+    }
 
-          break;
-        } else if (ch === 0x0A) {
+    if (str === "null") {
+      return null;
+    }
+
+    if (str === "BI") {
+      this.beginInlineImagePos = this.stream.pos;
+    }
+
+    return _primitives.Cmd.get(str);
+  }
+
+  skipToNextLine() {
+    let ch = this.currentChar;
+
+    while (ch >= 0) {
+      if (ch === 0x0d) {
+        ch = this.nextChar();
+
+        if (ch === 0x0a) {
           this.nextChar();
-          break;
         }
 
-        ch = this.nextChar();
+        break;
+      } else if (ch === 0x0a) {
+        this.nextChar();
+        break;
       }
+
+      ch = this.nextChar();
     }
-  };
-  return Lexer;
-}();
+  }
+
+}
 
 exports.Lexer = Lexer;
-var Linearization = {
-  create: function LinearizationCreate(stream) {
-    function getInt(name, allowZeroValue) {
-      var obj = linDict.get(name);
+
+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.');
+      throw new Error(`The "${name}" parameter in the linearization ` + "dictionary is invalid.");
     }
 
-    function getHints() {
-      var hints = linDict.get('H'),
-          hintsLength,
-          item;
+    function getHints(linDict) {
+      const hints = linDict.get("H");
+      let hintsLength;
 
       if (Array.isArray(hints) && ((hintsLength = hints.length) === 2 || hintsLength === 4)) {
-        for (var index = 0; index < hintsLength; index++) {
-          if (!(Number.isInteger(item = hints[index]) && item > 0)) {
-            throw new Error('Hint (' + index + ') in the linearization dictionary is invalid.');
+        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.');
+      throw new Error("Hint array in the linearization dictionary is invalid.");
     }
 
-    var parser = new Parser(new Lexer(stream), false, null);
-    var obj1 = parser.getObj();
-    var obj2 = parser.getObj();
-    var obj3 = parser.getObj();
-    var linDict = parser.getObj();
-    var obj, length;
-
-    if (!(Number.isInteger(obj1) && Number.isInteger(obj2) && (0, _primitives.isCmd)(obj3, 'obj') && (0, _primitives.isDict)(linDict) && (0, _util.isNum)(obj = linDict.get('Linearized')) && obj > 0)) {
+    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) && (0, _primitives.isCmd)(obj3, "obj") && (0, _primitives.isDict)(linDict) && (0, _util.isNum)(obj = linDict.get("Linearized")) && obj > 0)) {
       return null;
-    } else if ((length = getInt('L')) !== stream.length) {
-      throw new Error('The "L" parameter in the linearization dictionary ' + 'does not equal the stream length.');
+    } 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: length,
-      hints: getHints(),
-      objectNumberFirst: getInt('O'),
-      endFirst: getInt('E'),
-      numPages: getInt('N'),
-      mainXRefEntriesOffset: getInt('T'),
-      pageFirst: linDict.has('P') ? getInt('P', true) : 0
+      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", true) : 0
     };
   }
-};
+
+}
+
 exports.Linearization = Linearization;