pdfjs-dist 2.1.266 → 2.2.228

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 2019 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -40,6 +40,14 @@ var _jpeg_stream = require("./jpeg_stream");
 
 var _jpx_stream = require("./jpx_stream");
 
+var _core_utils = require("./core_utils");
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
 var MAX_LENGTH_TO_CACHE = 1000;
 var MAX_ADLER32_LENGTH = 5552;
 
@@ -56,22 +64,36 @@ function computeAdler32(bytes) {
   return b % 65521 << 16 | a % 65521;
 }
 
-var Parser = function ParserClosure() {
-  function Parser(lexer, allowStreams, xref, recoveryMode) {
+var Parser =
+/*#__PURE__*/
+function () {
+  function Parser(_ref) {
+    var lexer = _ref.lexer,
+        xref = _ref.xref,
+        _ref$allowStreams = _ref.allowStreams,
+        allowStreams = _ref$allowStreams === void 0 ? false : _ref$allowStreams,
+        _ref$recoveryMode = _ref.recoveryMode,
+        recoveryMode = _ref$recoveryMode === void 0 ? false : _ref$recoveryMode;
+
+    _classCallCheck(this, Parser);
+
     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() {
+  _createClass(Parser, [{
+    key: "refill",
+    value: function refill() {
       this.buf1 = this.lexer.getObj();
       this.buf2 = this.lexer.getObj();
-    },
-    shift: function Parser_shift() {
+    }
+  }, {
+    key: "shift",
+    value: function shift() {
       if ((0, _primitives.isCmd)(this.buf2, 'ID')) {
         this.buf1 = this.buf2;
         this.buf2 = null;
@@ -79,20 +101,24 @@ var Parser = function ParserClosure() {
         this.buf1 = this.buf2;
         this.buf2 = this.lexer.getObj();
       }
-    },
-    tryShift: function Parser_tryShift() {
+    }
+  }, {
+    key: "tryShift",
+    value: function tryShift() {
       try {
         this.shift();
         return true;
       } catch (e) {
-        if (e instanceof _util.MissingDataException) {
+        if (e instanceof _core_utils.MissingDataException) {
           throw e;
         }
 
         return false;
       }
-    },
-    getObj: function Parser_getObj(cipherTransform) {
+    }
+  }, {
+    key: "getObj",
+    value: function getObj(cipherTransform) {
       var buf1 = this.buf1;
       this.shift();
 
@@ -163,7 +189,8 @@ var Parser = function ParserClosure() {
         var num = buf1;
 
         if (Number.isInteger(this.buf1) && (0, _primitives.isCmd)(this.buf2, 'R')) {
-          var ref = new _primitives.Ref(num, this.buf1);
+          var ref = _primitives.Ref.get(num, this.buf1);
+
           this.shift();
           this.shift();
           return ref;
@@ -183,8 +210,10 @@ var Parser = function ParserClosure() {
       }
 
       return buf1;
-    },
-    findDefaultInlineStreamEnd: function findDefaultInlineStreamEnd(stream) {
+    }
+  }, {
+    key: "findDefaultInlineStreamEnd",
+    value: function findDefaultInlineStreamEnd(stream) {
       var E = 0x45,
           I = 0x49,
           SPACE = 0x20,
@@ -250,8 +279,10 @@ var Parser = function ParserClosure() {
       }
 
       return stream.pos - endOffset - startPos;
-    },
-    findDCTDecodeInlineStreamEnd: function Parser_findDCTDecodeInlineStreamEnd(stream) {
+    }
+  }, {
+    key: "findDCTDecodeInlineStreamEnd",
+    value: function findDCTDecodeInlineStreamEnd(stream) {
       var startPos = stream.pos,
           foundEOI = false,
           b,
@@ -339,8 +370,10 @@ var Parser = function ParserClosure() {
 
       this.inlineStreamSkipEI(stream);
       return length;
-    },
-    findASCII85DecodeInlineStreamEnd: function Parser_findASCII85DecodeInlineStreamEnd(stream) {
+    }
+  }, {
+    key: "findASCII85DecodeInlineStreamEnd",
+    value: function findASCII85DecodeInlineStreamEnd(stream) {
       var TILDE = 0x7E,
           GT = 0x3E;
       var startPos = stream.pos,
@@ -348,9 +381,18 @@ var Parser = function ParserClosure() {
           length;
 
       while ((ch = stream.getByte()) !== -1) {
-        if (ch === TILDE && stream.peekByte() === GT) {
-          stream.skip();
-          break;
+        if (ch === TILDE) {
+          ch = stream.peekByte();
+
+          while ((0, _util.isSpace)(ch)) {
+            stream.skip();
+            ch = stream.peekByte();
+          }
+
+          if (ch === GT) {
+            stream.skip();
+            break;
+          }
         }
       }
 
@@ -364,8 +406,10 @@ var Parser = function ParserClosure() {
 
       this.inlineStreamSkipEI(stream);
       return length;
-    },
-    findASCIIHexDecodeInlineStreamEnd: function Parser_findASCIIHexDecodeInlineStreamEnd(stream) {
+    }
+  }, {
+    key: "findASCIIHexDecodeInlineStreamEnd",
+    value: function findASCIIHexDecodeInlineStreamEnd(stream) {
       var GT = 0x3E;
       var startPos = stream.pos,
           ch,
@@ -387,8 +431,10 @@ var Parser = function ParserClosure() {
 
       this.inlineStreamSkipEI(stream);
       return length;
-    },
-    inlineStreamSkipEI: function Parser_inlineStreamSkipEI(stream) {
+    }
+  }, {
+    key: "inlineStreamSkipEI",
+    value: function inlineStreamSkipEI(stream) {
       var E = 0x45,
           I = 0x49;
       var state = 0,
@@ -403,12 +449,14 @@ var Parser = function ParserClosure() {
           break;
         }
       }
-    },
-    makeInlineImage: function Parser_makeInlineImage(cipherTransform) {
+    }
+  }, {
+    key: "makeInlineImage",
+    value: function makeInlineImage(cipherTransform) {
       var lexer = this.lexer;
       var stream = lexer.stream;
-      var dict = new _primitives.Dict(this.xref),
-          dictLength;
+      var dict = new _primitives.Dict(this.xref);
+      var dictLength;
 
       while (!(0, _primitives.isCmd)(this.buf1, 'ID') && !(0, _primitives.isEOF)(this.buf1)) {
         if (!(0, _primitives.isName)(this.buf1)) {
@@ -429,8 +477,8 @@ var Parser = function ParserClosure() {
         dictLength = stream.pos - lexer.beginInlineImagePos;
       }
 
-      var filter = dict.get('Filter', 'F'),
-          filterName;
+      var filter = dict.get('Filter', 'F');
+      var filterName;
 
       if ((0, _primitives.isName)(filter)) {
         filterName = filter.name;
@@ -442,8 +490,8 @@ var Parser = function ParserClosure() {
         }
       }
 
-      var startPos = stream.pos,
-          length;
+      var startPos = stream.pos;
+      var length;
 
       if (filterName === 'DCTDecode' || filterName === 'DCT') {
         length = this.findDCTDecodeInlineStreamEnd(stream);
@@ -484,15 +532,17 @@ var Parser = function ParserClosure() {
       imageStream.dict = dict;
 
       if (cacheKey !== undefined) {
-        imageStream.cacheKey = 'inline_' + length + '_' + cacheKey;
+        imageStream.cacheKey = "inline_".concat(length, "_").concat(cacheKey);
         this.imageCache[cacheKey] = imageStream;
       }
 
       this.buf2 = _primitives.Cmd.get('EI');
       this.shift();
       return imageStream;
-    },
-    _findStreamLength: function _findStreamLength(startPos, signature) {
+    }
+  }, {
+    key: "_findStreamLength",
+    value: function _findStreamLength(startPos, signature) {
       var stream = this.lexer.stream;
       stream.pos = startPos;
       var SCAN_BLOCK_LENGTH = 2048;
@@ -527,8 +577,10 @@ var Parser = function ParserClosure() {
       }
 
       return -1;
-    },
-    makeStream: function Parser_makeStream(dict, cipherTransform) {
+    }
+  }, {
+    key: "makeStream",
+    value: function makeStream(dict, cipherTransform) {
       var lexer = this.lexer;
       var stream = lexer.stream;
       lexer.skipToNextLine();
@@ -536,7 +588,7 @@ var Parser = function ParserClosure() {
       var length = dict.get('Length');
 
       if (!Number.isInteger(length)) {
-        (0, _util.info)('Bad ' + length + ' attribute in stream');
+        (0, _util.info)("Bad length \"".concat(length, "\" in stream"));
         length = 0;
       }
 
@@ -593,8 +645,10 @@ var Parser = function ParserClosure() {
       stream = this.filter(stream, dict, length);
       stream.dict = dict;
       return stream;
-    },
-    filter: function Parser_filter(stream, dict, length) {
+    }
+  }, {
+    key: "filter",
+    value: function filter(stream, dict, length) {
       var filter = dict.get('Filter', 'F');
       var params = dict.get('DecodeParms', 'DP');
 
@@ -616,7 +670,7 @@ var Parser = function ParserClosure() {
           filter = this.xref.fetchIfRef(filterArray[i]);
 
           if (!(0, _primitives.isName)(filter)) {
-            throw new _util.FormatError('Bad filter name: ' + filter);
+            throw new _util.FormatError("Bad filter name \"".concat(filter, "\""));
           }
 
           params = null;
@@ -631,10 +685,12 @@ var Parser = function ParserClosure() {
       }
 
       return stream;
-    },
-    makeFilter: function Parser_makeFilter(stream, name, maybeLength, params) {
+    }
+  }, {
+    key: "makeFilter",
+    value: function makeFilter(stream, name, maybeLength, params) {
       if (maybeLength === 0) {
-        (0, _util.warn)('Empty "' + name + '" stream.');
+        (0, _util.warn)("Empty \"".concat(name, "\" stream."));
         return new _stream.NullStream();
       }
 
@@ -701,54 +757,65 @@ var Parser = function ParserClosure() {
           return new _jbig2_stream.Jbig2Stream(stream, maybeLength, stream.dict, params);
         }
 
-        (0, _util.warn)('filter "' + name + '" not supported yet');
+        (0, _util.warn)("Filter \"".concat(name, "\" is not supported."));
         return stream;
       } catch (ex) {
-        if (ex instanceof _util.MissingDataException) {
+        if (ex instanceof _core_utils.MissingDataException) {
           throw ex;
         }
 
-        (0, _util.warn)('Invalid stream: \"' + ex + '\"');
+        (0, _util.warn)("Invalid stream: \"".concat(ex, "\""));
         return new _stream.NullStream();
       }
     }
-  };
+  }]);
+
   return Parser;
 }();
 
 exports.Parser = Parser;
+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];
 
-var Lexer = function LexerClosure() {
-  function Lexer(stream, knownCommands) {
-    this.stream = stream;
-    this.nextChar();
-    this.strBuf = [];
-    this.knownCommands = knownCommands;
-    this.beginInlineImagePos = -1;
+function toHexDigit(ch) {
+  if (ch >= 0x30 && ch <= 0x39) {
+    return ch & 0x0F;
   }
 
-  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];
+  if (ch >= 0x41 && ch <= 0x46 || ch >= 0x61 && ch <= 0x66) {
+    return (ch & 0x0F) + 9;
+  }
 
-  function toHexDigit(ch) {
-    if (ch >= 0x30 && ch <= 0x39) {
-      return ch & 0x0F;
-    }
+  return -1;
+}
 
-    if (ch >= 0x41 && ch <= 0x46 || ch >= 0x61 && ch <= 0x66) {
-      return (ch & 0x0F) + 9;
-    }
+var Lexer =
+/*#__PURE__*/
+function () {
+  function Lexer(stream) {
+    var knownCommands = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+
+    _classCallCheck(this, Lexer);
 
-    return -1;
+    this.stream = stream;
+    this.nextChar();
+    this.strBuf = [];
+    this.knownCommands = knownCommands;
+    this.beginInlineImagePos = -1;
   }
 
-  Lexer.prototype = {
-    nextChar: function Lexer_nextChar() {
+  _createClass(Lexer, [{
+    key: "nextChar",
+    value: function nextChar() {
       return this.currentChar = this.stream.getByte();
-    },
-    peekChar: function Lexer_peekChar() {
+    }
+  }, {
+    key: "peekChar",
+    value: function peekChar() {
       return this.stream.peekByte();
-    },
-    getNumber: function Lexer_getNumber() {
+    }
+  }, {
+    key: "getNumber",
+    value: function getNumber() {
       var ch = this.currentChar;
       var eNotation = false;
       var divideBy = 0;
@@ -811,7 +878,7 @@ var Lexer = function LexerClosure() {
             break;
           }
         } else if (ch === 0x2D) {
-          (0, _util.warn)('Badly formatted number');
+          (0, _util.warn)('Badly formatted number: minus sign in the middle');
         } else if (ch === 0x45 || ch === 0x65) {
           ch = this.peekChar();
 
@@ -837,8 +904,10 @@ var Lexer = function LexerClosure() {
       }
 
       return sign * baseValue;
-    },
-    getString: function Lexer_getString() {
+    }
+  }, {
+    key: "getString",
+    value: function getString() {
       var numParen = 1;
       var done = false;
       var strBuf = this.strBuf;
@@ -961,8 +1030,10 @@ var Lexer = function LexerClosure() {
       }
 
       return strBuf.join('');
-    },
-    getName: function Lexer_getName() {
+    }
+  }, {
+    key: "getName",
+    value: function getName() {
       var ch, previousCh;
       var strBuf = this.strBuf;
       strBuf.length = 0;
@@ -985,7 +1056,7 @@ var Lexer = function LexerClosure() {
             var x2 = toHexDigit(ch);
 
             if (x2 === -1) {
-              (0, _util.warn)('Lexer_getName: Illegal digit (' + String.fromCharCode(ch) + ') in hexadecimal number.');
+              (0, _util.warn)("Lexer_getName: Illegal digit (".concat(String.fromCharCode(ch), ") ") + 'in hexadecimal number.');
               strBuf.push('#', String.fromCharCode(previousCh));
 
               if (specialChars[ch]) {
@@ -1006,18 +1077,19 @@ var Lexer = function LexerClosure() {
       }
 
       if (strBuf.length > 127) {
-        (0, _util.warn)('name token is longer than allowed by the spec: ' + strBuf.length);
+        (0, _util.warn)("Name token is longer than allowed by the spec: ".concat(strBuf.length));
       }
 
       return _primitives.Name.get(strBuf.join(''));
-    },
-    getHexString: function Lexer_getHexString() {
+    }
+  }, {
+    key: "getHexString",
+    value: function getHexString() {
       var strBuf = this.strBuf;
       strBuf.length = 0;
       var ch = this.currentChar;
       var isFirstHex = true;
-      var firstDigit;
-      var secondDigit;
+      var firstDigit, secondDigit;
 
       while (true) {
         if (ch < 0) {
@@ -1034,7 +1106,7 @@ var Lexer = function LexerClosure() {
             firstDigit = toHexDigit(ch);
 
             if (firstDigit === -1) {
-              (0, _util.warn)('Ignoring invalid character "' + ch + '" in hex string');
+              (0, _util.warn)("Ignoring invalid character \"".concat(ch, "\" in hex string"));
               ch = this.nextChar();
               continue;
             }
@@ -1042,7 +1114,7 @@ var Lexer = function LexerClosure() {
             secondDigit = toHexDigit(ch);
 
             if (secondDigit === -1) {
-              (0, _util.warn)('Ignoring invalid character "' + ch + '" in hex string');
+              (0, _util.warn)("Ignoring invalid character \"".concat(ch, "\" in hex string"));
               ch = this.nextChar();
               continue;
             }
@@ -1056,8 +1128,10 @@ var Lexer = function LexerClosure() {
       }
 
       return strBuf.join('');
-    },
-    getObj: function Lexer_getObj() {
+    }
+  }, {
+    key: "getObj",
+    value: function getObj() {
       var comment = false;
       var ch = this.currentChar;
 
@@ -1178,8 +1252,10 @@ var Lexer = function LexerClosure() {
       }
 
       return _primitives.Cmd.get(str);
-    },
-    skipToNextLine: function Lexer_skipToNextLine() {
+    }
+  }, {
+    key: "skipToNextLine",
+    value: function skipToNextLine() {
       var ch = this.currentChar;
 
       while (ch >= 0) {
@@ -1199,63 +1275,82 @@ var Lexer = function LexerClosure() {
         ch = this.nextChar();
       }
     }
-  };
+  }]);
+
   return Lexer;
 }();
 
 exports.Lexer = Lexer;
-var Linearization = {
-  create: function LinearizationCreate(stream) {
-    function getInt(name, allowZeroValue) {
-      var obj = linDict.get(name);
 
-      if (Number.isInteger(obj) && (allowZeroValue ? obj >= 0 : obj > 0)) {
-        return obj;
+var Linearization =
+/*#__PURE__*/
+function () {
+  function Linearization() {
+    _classCallCheck(this, Linearization);
+  }
+
+  _createClass(Linearization, null, [{
+    key: "create",
+    value: function create(stream) {
+      function getInt(linDict, name) {
+        var allowZeroValue = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+        var obj = linDict.get(name);
+
+        if (Number.isInteger(obj) && (allowZeroValue ? obj >= 0 : obj > 0)) {
+          return obj;
+        }
+
+        throw new Error("The \"".concat(name, "\" parameter in the linearization ") + 'dictionary is invalid.');
       }
 
-      throw new Error('The "' + name + '" parameter in the linearization ' + 'dictionary is invalid.');
-    }
+      function getHints(linDict) {
+        var hints = linDict.get('H');
+        var hintsLength;
 
-    function getHints() {
-      var hints = linDict.get('H'),
-          hintsLength,
-          item;
+        if (Array.isArray(hints) && ((hintsLength = hints.length) === 2 || hintsLength === 4)) {
+          for (var index = 0; index < hintsLength; index++) {
+            var hint = hints[index];
 
-      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.');
+            if (!(Number.isInteger(hint) && hint > 0)) {
+              throw new Error("Hint (".concat(index, ") in the linearization dictionary ") + 'is invalid.');
+            }
           }
+
+          return hints;
         }
 
-        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({
+        lexer: new Lexer(stream),
+        xref: 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)) {
+        return null;
+      } else if ((length = getInt(linDict, 'L')) !== stream.length) {
+        throw new Error('The "L" parameter in the linearization dictionary ' + 'does not equal the stream length.');
+      }
 
-    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)) {
-      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.');
+      return {
+        length: 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
+      };
     }
+  }]);
+
+  return Linearization;
+}();
 
-    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
-    };
-  }
-};
 exports.Linearization = Linearization;

package/lib/core/pattern.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 2019 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -33,6 +33,8 @@ var _colorspace = require("./colorspace");
 
 var _primitives = require("./primitives");
 
+var _core_utils = require("./core_utils");
+
 var ShadingType = {
   FUNCTION_BASED: 1,
   AXIAL: 2,
@@ -74,7 +76,7 @@ var Pattern = function PatternClosure() {
           throw new _util.FormatError('Unsupported ShadingType: ' + type);
       }
     } catch (ex) {
-      if (ex instanceof _util.MissingDataException) {
+      if (ex instanceof _core_utils.MissingDataException) {
         throw ex;
       }