pdfjs-dist 2.0.550 → 2.3.200

package/lib/core/jpg.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2017 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.
@@ -19,45 +19,75 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.JpegImage = undefined;
+exports.JpegImage = void 0;
 
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+var _util = require("../shared/util");
 
-var _util = require('../shared/util');
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+var JpegError =
+/*#__PURE__*/
+function (_BaseException) {
+  _inherits(JpegError, _BaseException);
 
-var JpegError = function JpegErrorClosure() {
   function JpegError(msg) {
-    this.message = 'JPEG error: ' + msg;
+    _classCallCheck(this, JpegError);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(JpegError).call(this, "JPEG error: ".concat(msg)));
   }
-  JpegError.prototype = new Error();
-  JpegError.prototype.name = 'JpegError';
-  JpegError.constructor = JpegError;
+
   return JpegError;
-}();
-var DNLMarkerError = function DNLMarkerErrorClosure() {
+}(_util.BaseException);
+
+var DNLMarkerError =
+/*#__PURE__*/
+function (_BaseException2) {
+  _inherits(DNLMarkerError, _BaseException2);
+
   function DNLMarkerError(message, scanLines) {
-    this.message = message;
-    this.scanLines = scanLines;
+    var _this;
+
+    _classCallCheck(this, DNLMarkerError);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(DNLMarkerError).call(this, message));
+    _this.scanLines = scanLines;
+    return _this;
   }
-  DNLMarkerError.prototype = new Error();
-  DNLMarkerError.prototype.name = 'DNLMarkerError';
-  DNLMarkerError.constructor = DNLMarkerError;
+
   return DNLMarkerError;
-}();
-var EOIMarkerError = function EOIMarkerErrorClosure() {
-  function EOIMarkerError(message) {
-    this.message = message;
+}(_util.BaseException);
+
+var EOIMarkerError =
+/*#__PURE__*/
+function (_BaseException3) {
+  _inherits(EOIMarkerError, _BaseException3);
+
+  function EOIMarkerError() {
+    _classCallCheck(this, EOIMarkerError);
+
+    return _possibleConstructorReturn(this, _getPrototypeOf(EOIMarkerError).apply(this, arguments));
   }
-  EOIMarkerError.prototype = new Error();
-  EOIMarkerError.prototype.name = 'EOIMarkerError';
-  EOIMarkerError.constructor = EOIMarkerError;
+
   return EOIMarkerError;
-}();
+}(_util.BaseException);
+
 var JpegImage = function JpegImageClosure() {
   var dctZigZag = new Uint8Array([0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40, 48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36, 29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61, 54, 47, 55, 62, 63]);
   var dctCos1 = 4017;
@@ -68,34 +98,48 @@ var JpegImage = function JpegImageClosure() {
   var dctSin6 = 3784;
   var dctSqrt2 = 5793;
   var dctSqrt1d2 = 2896;
+
   function JpegImage() {
-    this.decodeTransform = null;
-    this.colorTransform = -1;
+    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+        _ref$decodeTransform = _ref.decodeTransform,
+        decodeTransform = _ref$decodeTransform === void 0 ? null : _ref$decodeTransform,
+        _ref$colorTransform = _ref.colorTransform,
+        colorTransform = _ref$colorTransform === void 0 ? -1 : _ref$colorTransform;
+
+    this._decodeTransform = decodeTransform;
+    this._colorTransform = colorTransform;
   }
+
   function buildHuffmanTable(codeLengths, values) {
     var k = 0,
         code = [],
         i,
         j,
         length = 16;
+
     while (length > 0 && !codeLengths[length - 1]) {
       length--;
     }
+
     code.push({
       children: [],
       index: 0
     });
     var p = code[0],
         q;
+
     for (i = 0; i < length; i++) {
       for (j = 0; j < codeLengths[i]; j++) {
         p = code.pop();
         p.children[p.index] = values[k];
+
         while (p.index > 0) {
           p = code.pop();
         }
+
         p.index++;
         code.push(p);
+
         while (code.length <= i) {
           code.push(q = {
             children: [],
@@ -104,8 +148,10 @@ var JpegImage = function JpegImageClosure() {
           p.children[p.index] = q.children;
           p = q;
         }
+
         k++;
       }
+
       if (i + 1 < length) {
         code.push(q = {
           children: [],
@@ -115,145 +161,184 @@ var JpegImage = function JpegImageClosure() {
         p = q;
       }
     }
+
     return code[0].children;
   }
+
   function getBlockBufferOffset(component, row, col) {
     return 64 * ((component.blocksPerLine + 1) * row + col);
   }
+
   function decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive) {
     var parseDNLMarker = arguments.length > 9 && arguments[9] !== undefined ? arguments[9] : false;
-
     var mcusPerLine = frame.mcusPerLine;
     var progressive = frame.progressive;
     var startOffset = offset,
         bitsData = 0,
         bitsCount = 0;
+
     function readBit() {
       if (bitsCount > 0) {
         bitsCount--;
         return bitsData >> bitsCount & 1;
       }
+
       bitsData = data[offset++];
+
       if (bitsData === 0xFF) {
         var nextByte = data[offset++];
+
         if (nextByte) {
           if (nextByte === 0xDC && parseDNLMarker) {
             offset += 2;
             var scanLines = data[offset++] << 8 | data[offset++];
+
             if (scanLines > 0 && scanLines !== frame.scanLines) {
               throw new DNLMarkerError('Found DNL marker (0xFFDC) while parsing scan data', scanLines);
             }
           } else if (nextByte === 0xD9) {
             throw new EOIMarkerError('Found EOI marker (0xFFD9) while parsing scan data');
           }
-          throw new JpegError('unexpected marker ' + (bitsData << 8 | nextByte).toString(16));
+
+          throw new JpegError("unexpected marker ".concat((bitsData << 8 | nextByte).toString(16)));
         }
       }
+
       bitsCount = 7;
       return bitsData >>> 7;
     }
+
     function decodeHuffman(tree) {
       var node = tree;
+
       while (true) {
         node = node[readBit()];
+
         if (typeof node === 'number') {
           return node;
         }
-        if ((typeof node === 'undefined' ? 'undefined' : _typeof(node)) !== 'object') {
+
+        if (_typeof(node) !== 'object') {
           throw new JpegError('invalid huffman sequence');
         }
       }
     }
+
     function receive(length) {
       var n = 0;
+
       while (length > 0) {
         n = n << 1 | readBit();
         length--;
       }
+
       return n;
     }
+
     function receiveAndExtend(length) {
       if (length === 1) {
         return readBit() === 1 ? 1 : -1;
       }
+
       var n = receive(length);
+
       if (n >= 1 << length - 1) {
         return n;
       }
+
       return n + (-1 << length) + 1;
     }
+
     function decodeBaseline(component, offset) {
       var t = decodeHuffman(component.huffmanTableDC);
       var diff = t === 0 ? 0 : receiveAndExtend(t);
       component.blockData[offset] = component.pred += diff;
       var k = 1;
+
       while (k < 64) {
         var rs = decodeHuffman(component.huffmanTableAC);
         var s = rs & 15,
             r = rs >> 4;
+
         if (s === 0) {
           if (r < 15) {
             break;
           }
+
           k += 16;
           continue;
         }
+
         k += r;
         var z = dctZigZag[k];
         component.blockData[offset + z] = receiveAndExtend(s);
         k++;
       }
     }
+
     function decodeDCFirst(component, offset) {
       var t = decodeHuffman(component.huffmanTableDC);
       var diff = t === 0 ? 0 : receiveAndExtend(t) << successive;
       component.blockData[offset] = component.pred += diff;
     }
+
     function decodeDCSuccessive(component, offset) {
       component.blockData[offset] |= readBit() << successive;
     }
+
     var eobrun = 0;
+
     function decodeACFirst(component, offset) {
       if (eobrun > 0) {
         eobrun--;
         return;
       }
+
       var k = spectralStart,
           e = spectralEnd;
+
       while (k <= e) {
         var rs = decodeHuffman(component.huffmanTableAC);
         var s = rs & 15,
             r = rs >> 4;
+
         if (s === 0) {
           if (r < 15) {
             eobrun = receive(r) + (1 << r) - 1;
             break;
           }
+
           k += 16;
           continue;
         }
+
         k += r;
         var z = dctZigZag[k];
         component.blockData[offset + z] = receiveAndExtend(s) * (1 << successive);
         k++;
       }
     }
+
     var successiveACState = 0,
         successiveACNextValue;
+
     function decodeACSuccessive(component, offset) {
       var k = spectralStart;
       var e = spectralEnd;
       var r = 0;
       var s;
       var rs;
+
       while (k <= e) {
         var offsetZ = offset + dctZigZag[k];
         var sign = component.blockData[offsetZ] < 0 ? -1 : 1;
+
         switch (successiveACState) {
           case 0:
             rs = decodeHuffman(component.huffmanTableAC);
             s = rs & 15;
             r = rs >> 4;
+
             if (s === 0) {
               if (r < 15) {
                 eobrun = receive(r) + (1 << r);
@@ -266,21 +351,27 @@ var JpegImage = function JpegImageClosure() {
               if (s !== 1) {
                 throw new JpegError('invalid ACn encoding');
               }
+
               successiveACNextValue = receiveAndExtend(s);
               successiveACState = r ? 2 : 3;
             }
+
             continue;
+
           case 1:
           case 2:
             if (component.blockData[offsetZ]) {
               component.blockData[offsetZ] += sign * (readBit() << successive);
             } else {
               r--;
+
               if (r === 0) {
                 successiveACState = successiveACState === 2 ? 3 : 0;
               }
             }
+
             break;
+
           case 3:
             if (component.blockData[offsetZ]) {
               component.blockData[offsetZ] += sign * (readBit() << successive);
@@ -288,22 +379,29 @@ var JpegImage = function JpegImageClosure() {
               component.blockData[offsetZ] = successiveACNextValue << successive;
               successiveACState = 0;
             }
+
             break;
+
           case 4:
             if (component.blockData[offsetZ]) {
               component.blockData[offsetZ] += sign * (readBit() << successive);
             }
+
             break;
         }
+
         k++;
       }
+
       if (successiveACState === 4) {
         eobrun--;
+
         if (eobrun === 0) {
           successiveACState = 0;
         }
       }
     }
+
     function decodeMcu(component, decode, mcu, row, col) {
       var mcuRow = mcu / mcusPerLine | 0;
       var mcuCol = mcu % mcusPerLine;
@@ -312,15 +410,18 @@ var JpegImage = function JpegImageClosure() {
       var offset = getBlockBufferOffset(component, blockRow, blockCol);
       decode(component, offset);
     }
+
     function decodeBlock(component, decode, mcu) {
       var blockRow = mcu / component.blocksPerLine | 0;
       var blockCol = mcu % component.blocksPerLine;
       var offset = getBlockBufferOffset(component, blockRow, blockCol);
       decode(component, offset);
     }
+
     var componentsLength = components.length;
     var component, i, j, k, n;
     var decodeFn;
+
     if (progressive) {
       if (spectralStart === 0) {
         decodeFn = successivePrev === 0 ? decodeDCFirst : decodeDCSuccessive;
@@ -330,23 +431,31 @@ var JpegImage = function JpegImageClosure() {
     } else {
       decodeFn = decodeBaseline;
     }
+
     var mcu = 0,
         fileMarker;
     var mcuExpected;
+
     if (componentsLength === 1) {
       mcuExpected = components[0].blocksPerLine * components[0].blocksPerColumn;
     } else {
       mcuExpected = mcusPerLine * frame.mcusPerColumn;
     }
+
     var h, v;
+
     while (mcu < mcuExpected) {
       var mcuToRead = resetInterval ? Math.min(mcuExpected - mcu, resetInterval) : mcuExpected;
+
       for (i = 0; i < componentsLength; i++) {
         components[i].pred = 0;
       }
+
       eobrun = 0;
+
       if (componentsLength === 1) {
         component = components[0];
+
         for (n = 0; n < mcuToRead; n++) {
           decodeBlock(component, decodeFn, mcu);
           mcu++;
@@ -357,47 +466,62 @@ var JpegImage = function JpegImageClosure() {
             component = components[i];
             h = component.h;
             v = component.v;
+
             for (j = 0; j < v; j++) {
               for (k = 0; k < h; k++) {
                 decodeMcu(component, decodeFn, mcu, j, k);
               }
             }
           }
+
           mcu++;
         }
       }
+
       bitsCount = 0;
       fileMarker = findNextFileMarker(data, offset);
-      if (fileMarker && fileMarker.invalid) {
+
+      if (!fileMarker) {
+        break;
+      } else if (fileMarker.invalid) {
         (0, _util.warn)('decodeScan - unexpected MCU data, current marker is: ' + fileMarker.invalid);
         offset = fileMarker.offset;
       }
+
       var marker = fileMarker && fileMarker.marker;
+
       if (!marker || marker <= 0xFF00) {
-        throw new JpegError('marker was not found');
+        throw new JpegError('decodeScan - a valid marker was not found.');
       }
+
       if (marker >= 0xFFD0 && marker <= 0xFFD7) {
         offset += 2;
       } else {
         break;
       }
     }
+
     fileMarker = findNextFileMarker(data, offset);
+
     if (fileMarker && fileMarker.invalid) {
       (0, _util.warn)('decodeScan - unexpected Scan data, current marker is: ' + fileMarker.invalid);
       offset = fileMarker.offset;
     }
+
     return offset - startOffset;
   }
+
   function quantizeAndInverse(component, blockBufferOffset, p) {
     var qt = component.quantizationTable,
         blockData = component.blockData;
     var v0, v1, v2, v3, v4, v5, v6, v7;
     var p0, p1, p2, p3, p4, p5, p6, p7;
     var t;
+
     if (!qt) {
       throw new JpegError('missing required Quantization Table.');
     }
+
     for (var row = 0; row < 64; row += 8) {
       p0 = blockData[blockBufferOffset + row];
       p1 = blockData[blockBufferOffset + row + 1];
@@ -408,6 +532,7 @@ var JpegImage = function JpegImageClosure() {
       p6 = blockData[blockBufferOffset + row + 6];
       p7 = blockData[blockBufferOffset + row + 7];
       p0 *= qt[row];
+
       if ((p1 | p2 | p3 | p4 | p5 | p6 | p7) === 0) {
         t = dctSqrt2 * p0 + 512 >> 10;
         p[row] = t;
@@ -420,6 +545,7 @@ var JpegImage = function JpegImageClosure() {
         p[row + 7] = t;
         continue;
       }
+
       p1 *= qt[row + 1];
       p2 *= qt[row + 2];
       p3 *= qt[row + 3];
@@ -463,6 +589,7 @@ var JpegImage = function JpegImageClosure() {
       p[row + 3] = v3 + v4;
       p[row + 4] = v3 - v4;
     }
+
     for (var col = 0; col < 8; ++col) {
       p0 = p[col];
       p1 = p[col + 8];
@@ -472,6 +599,7 @@ var JpegImage = function JpegImageClosure() {
       p5 = p[col + 40];
       p6 = p[col + 48];
       p7 = p[col + 56];
+
       if ((p1 | p2 | p3 | p4 | p5 | p6 | p7) === 0) {
         t = dctSqrt2 * p0 + 8192 >> 14;
         t = t < -2040 ? 0 : t >= 2024 ? 255 : t + 2056 >> 4;
@@ -485,6 +613,7 @@ var JpegImage = function JpegImageClosure() {
         blockData[blockBufferOffset + col + 56] = t;
         continue;
       }
+
       v0 = dctSqrt2 * p0 + 2048 >> 12;
       v1 = dctSqrt2 * p4 + 2048 >> 12;
       v2 = p2;
@@ -538,30 +667,38 @@ var JpegImage = function JpegImageClosure() {
       blockData[blockBufferOffset + col + 56] = p7;
     }
   }
+
   function buildComponentData(frame, component) {
     var blocksPerLine = component.blocksPerLine;
     var blocksPerColumn = component.blocksPerColumn;
     var computationBuffer = new Int16Array(64);
+
     for (var blockRow = 0; blockRow < blocksPerColumn; blockRow++) {
       for (var blockCol = 0; blockCol < blocksPerLine; blockCol++) {
         var offset = getBlockBufferOffset(component, blockRow, blockCol);
         quantizeAndInverse(component, offset, computationBuffer);
       }
     }
+
     return component.blockData;
   }
+
   function findNextFileMarker(data, currentPos) {
     var startPos = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : currentPos;
 
     function peekUint16(pos) {
       return data[pos] << 8 | data[pos + 1];
     }
+
     var maxPos = data.length - 1;
     var newPos = startPos < currentPos ? startPos : currentPos;
+
     if (currentPos >= maxPos) {
       return null;
     }
+
     var currentMarker = peekUint16(currentPos);
+
     if (currentMarker >= 0xFFC0 && currentMarker <= 0xFFFE) {
       return {
         invalid: null,
@@ -569,45 +706,55 @@ var JpegImage = function JpegImageClosure() {
         offset: currentPos
       };
     }
+
     var newMarker = peekUint16(newPos);
+
     while (!(newMarker >= 0xFFC0 && newMarker <= 0xFFFE)) {
       if (++newPos >= maxPos) {
         return null;
       }
+
       newMarker = peekUint16(newPos);
     }
+
     return {
       invalid: currentMarker.toString(16),
       marker: newMarker,
       offset: newPos
     };
   }
+
   JpegImage.prototype = {
     parse: function parse(data) {
-      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-          _ref$dnlScanLines = _ref.dnlScanLines,
-          dnlScanLines = _ref$dnlScanLines === undefined ? null : _ref$dnlScanLines;
+      var _ref2 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
+          _ref2$dnlScanLines = _ref2.dnlScanLines,
+          dnlScanLines = _ref2$dnlScanLines === void 0 ? null : _ref2$dnlScanLines;
 
       function readUint16() {
         var value = data[offset] << 8 | data[offset + 1];
         offset += 2;
         return value;
       }
+
       function readDataBlock() {
         var length = readUint16();
         var endOffset = offset + length - 2;
         var fileMarker = findNextFileMarker(data, endOffset, offset);
+
         if (fileMarker && fileMarker.invalid) {
           (0, _util.warn)('readDataBlock - incorrect length, current marker is: ' + fileMarker.invalid);
           endOffset = fileMarker.offset;
         }
+
         var array = data.subarray(offset, endOffset);
         offset += array.length;
         return array;
       }
+
       function prepareComponents(frame) {
         var mcusPerLine = Math.ceil(frame.samplesPerLine / 8 / frame.maxH);
         var mcusPerColumn = Math.ceil(frame.scanLines / 8 / frame.maxV);
+
         for (var i = 0; i < frame.components.length; i++) {
           component = frame.components[i];
           var blocksPerLine = Math.ceil(Math.ceil(frame.samplesPerLine / 8) * component.h / frame.maxH);
@@ -619,9 +766,11 @@ var JpegImage = function JpegImageClosure() {
           component.blocksPerLine = blocksPerLine;
           component.blocksPerColumn = blocksPerColumn;
         }
+
         frame.mcusPerLine = mcusPerLine;
         frame.mcusPerColumn = mcusPerColumn;
       }
+
       var offset = 0;
       var jfif = null;
       var adobe = null;
@@ -631,12 +780,16 @@ var JpegImage = function JpegImageClosure() {
       var huffmanTablesAC = [],
           huffmanTablesDC = [];
       var fileMarker = readUint16();
+
       if (fileMarker !== 0xFFD8) {
         throw new JpegError('SOI not found');
       }
+
       fileMarker = readUint16();
+
       markerLoop: while (fileMarker !== 0xFFD9) {
         var i, j, l;
+
         switch (fileMarker) {
           case 0xFFE0:
           case 0xFFE1:
@@ -656,6 +809,7 @@ var JpegImage = function JpegImageClosure() {
           case 0xFFEF:
           case 0xFFFE:
             var appData = readDataBlock();
+
             if (fileMarker === 0xFFE0) {
               if (appData[0] === 0x4A && appData[1] === 0x46 && appData[2] === 0x49 && appData[3] === 0x46 && appData[4] === 0) {
                 jfif = {
@@ -672,6 +826,7 @@ var JpegImage = function JpegImageClosure() {
                 };
               }
             }
+
             if (fileMarker === 0xFFEE) {
               if (appData[0] === 0x41 && appData[1] === 0x64 && appData[2] === 0x6F && appData[3] === 0x62 && appData[4] === 0x65) {
                 adobe = {
@@ -682,14 +837,18 @@ var JpegImage = function JpegImageClosure() {
                 };
               }
             }
+
             break;
+
           case 0xFFDB:
             var quantizationTablesLength = readUint16();
             var quantizationTablesEnd = quantizationTablesLength + offset - 2;
             var z;
+
             while (offset < quantizationTablesEnd) {
               var quantizationTableSpec = data[offset++];
               var tableData = new Uint16Array(64);
+
               if (quantizationTableSpec >> 4 === 0) {
                 for (j = 0; j < 64; j++) {
                   z = dctZigZag[j];
@@ -703,15 +862,19 @@ var JpegImage = function JpegImageClosure() {
               } else {
                 throw new JpegError('DQT - invalid table spec');
               }
+
               quantizationTables[quantizationTableSpec & 15] = tableData;
             }
+
             break;
+
           case 0xFFC0:
           case 0xFFC1:
           case 0xFFC2:
             if (frame) {
               throw new JpegError('Only single frame JPEGs supported');
             }
+
             readUint16();
             frame = {};
             frame.extended = fileMarker === 0xFFC1;
@@ -726,16 +889,20 @@ var JpegImage = function JpegImageClosure() {
                 componentId;
             var maxH = 0,
                 maxV = 0;
+
             for (i = 0; i < componentsCount; i++) {
               componentId = data[offset];
               var h = data[offset + 1] >> 4;
               var v = data[offset + 1] & 15;
+
               if (maxH < h) {
                 maxH = h;
               }
+
               if (maxV < v) {
                 maxV = v;
               }
+
               var qId = data[offset + 2];
               l = frame.components.push({
                 h: h,
@@ -746,37 +913,48 @@ var JpegImage = function JpegImageClosure() {
               frame.componentIds[componentId] = l - 1;
               offset += 3;
             }
+
             frame.maxH = maxH;
             frame.maxV = maxV;
             prepareComponents(frame);
             break;
+
           case 0xFFC4:
             var huffmanLength = readUint16();
+
             for (i = 2; i < huffmanLength;) {
               var huffmanTableSpec = data[offset++];
               var codeLengths = new Uint8Array(16);
               var codeLengthSum = 0;
+
               for (j = 0; j < 16; j++, offset++) {
                 codeLengthSum += codeLengths[j] = data[offset];
               }
+
               var huffmanValues = new Uint8Array(codeLengthSum);
+
               for (j = 0; j < codeLengthSum; j++, offset++) {
                 huffmanValues[j] = data[offset];
               }
+
               i += 17 + codeLengthSum;
               (huffmanTableSpec >> 4 === 0 ? huffmanTablesDC : huffmanTablesAC)[huffmanTableSpec & 15] = buildHuffmanTable(codeLengths, huffmanValues);
             }
+
             break;
+
           case 0xFFDD:
             readUint16();
             resetInterval = readUint16();
             break;
+
           case 0xFFDA:
             var parseDNLMarker = ++numSOSMarkers === 1 && !dnlScanLines;
             readUint16();
             var selectorsCount = data[offset++];
             var components = [],
                 component;
+
             for (i = 0; i < selectorsCount; i++) {
               var componentIndex = frame.componentIds[data[offset++]];
               component = frame.components[componentIndex];
@@ -785,57 +963,80 @@ var JpegImage = function JpegImageClosure() {
               component.huffmanTableAC = huffmanTablesAC[tableSpec & 15];
               components.push(component);
             }
+
             var spectralStart = data[offset++];
             var spectralEnd = data[offset++];
             var successiveApproximation = data[offset++];
+
             try {
               var processed = decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successiveApproximation >> 4, successiveApproximation & 15, parseDNLMarker);
               offset += processed;
             } catch (ex) {
               if (ex instanceof DNLMarkerError) {
-                (0, _util.warn)(ex.message + ' -- attempting to re-parse the JPEG image.');
-                return this.parse(data, { dnlScanLines: ex.scanLines });
+                (0, _util.warn)("".concat(ex.message, " -- attempting to re-parse the JPEG image."));
+                return this.parse(data, {
+                  dnlScanLines: ex.scanLines
+                });
               } else if (ex instanceof EOIMarkerError) {
-                (0, _util.warn)(ex.message + ' -- ignoring the rest of the image data.');
+                (0, _util.warn)("".concat(ex.message, " -- ignoring the rest of the image data."));
                 break markerLoop;
               }
+
               throw ex;
             }
+
             break;
+
           case 0xFFDC:
             offset += 4;
             break;
+
           case 0xFFFF:
             if (data[offset] !== 0xFF) {
               offset--;
             }
+
             break;
+
           default:
             if (data[offset - 3] === 0xFF && data[offset - 2] >= 0xC0 && data[offset - 2] <= 0xFE) {
               offset -= 3;
               break;
             }
+
             var nextFileMarker = findNextFileMarker(data, offset - 2);
+
             if (nextFileMarker && nextFileMarker.invalid) {
               (0, _util.warn)('JpegImage.parse - unexpected data, current marker is: ' + nextFileMarker.invalid);
               offset = nextFileMarker.offset;
               break;
             }
-            throw new JpegError('unknown marker ' + fileMarker.toString(16));
+
+            if (offset > data.length - 2) {
+              (0, _util.warn)('JpegImage.parse - reached the end of the image data ' + 'without finding an EOI marker (0xFFD9).');
+              break markerLoop;
+            }
+
+            throw new JpegError('JpegImage.parse - unknown marker: ' + fileMarker.toString(16));
         }
+
         fileMarker = readUint16();
       }
+
       this.width = frame.samplesPerLine;
       this.height = frame.scanLines;
       this.jfif = jfif;
       this.adobe = adobe;
       this.components = [];
+
       for (i = 0; i < frame.components.length; i++) {
         component = frame.components[i];
         var quantizationTable = quantizationTables[component.quantizationId];
+
         if (quantizationTable) {
           component.quantizationTable = quantizationTable;
         }
+
         this.components.push({
           output: buildComponentData(frame, component),
           scaleX: component.h / frame.maxH,
@@ -844,10 +1045,12 @@ var JpegImage = function JpegImageClosure() {
           blocksPerColumn: component.blocksPerColumn
         });
       }
+
       this.numComponents = this.components.length;
+      return undefined;
     },
-
-    _getLinearizedBlockData: function getLinearizedBlockData(width, height) {
+    _getLinearizedBlockData: function _getLinearizedBlockData(width, height) {
+      var isSourcePDF = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
       var scaleX = this.width / width,
           scaleY = this.height / height;
       var component, componentScaleX, componentScaleY, blocksPerScanline;
@@ -860,6 +1063,7 @@ var JpegImage = function JpegImageClosure() {
       var data = new Uint8ClampedArray(dataLength);
       var xScaleBlockOffset = new Uint32Array(width);
       var mask3LSB = 0xfffffff8;
+
       for (i = 0; i < numComponents; i++) {
         component = this.components[i];
         componentScaleX = component.scaleX * scaleX;
@@ -867,20 +1071,29 @@ var JpegImage = function JpegImageClosure() {
         offset = i;
         output = component.output;
         blocksPerScanline = component.blocksPerLine + 1 << 3;
+
         for (x = 0; x < width; x++) {
           j = 0 | x * componentScaleX;
           xScaleBlockOffset[x] = (j & mask3LSB) << 3 | j & 7;
         }
+
         for (y = 0; y < height; y++) {
           j = 0 | y * componentScaleY;
           index = blocksPerScanline * (j & mask3LSB) | (j & 7) << 3;
+
           for (x = 0; x < width; x++) {
             data[offset] = output[index + xScaleBlockOffset[x]];
             offset += numComponents;
           }
         }
       }
-      var transform = this.decodeTransform;
+
+      var transform = this._decodeTransform;
+
+      if (!isSourcePDF && numComponents === 4 && !transform) {
+        transform = new Int32Array([-256, 255, -256, 255, -256, 255, -256, 255]);
+      }
+
       if (transform) {
         for (i = 0; i < dataLength;) {
           for (j = 0, k = 0; j < numComponents; j++, i++, k += 2) {
@@ -888,26 +1101,33 @@ var JpegImage = function JpegImageClosure() {
           }
         }
       }
+
       return data;
     },
-    _isColorConversionNeeded: function _isColorConversionNeeded() {
+
+    get _isColorConversionNeeded() {
       if (this.adobe) {
         return !!this.adobe.transformCode;
       }
+
       if (this.numComponents === 3) {
-        if (this.colorTransform === 0) {
+        if (this._colorTransform === 0) {
           return false;
         }
+
         return true;
       }
-      if (this.colorTransform === 1) {
+
+      if (this._colorTransform === 1) {
         return true;
       }
+
       return false;
     },
 
     _convertYccToRgb: function convertYccToRgb(data) {
       var Y, Cb, Cr;
+
       for (var i = 0, length = data.length; i < length; i += 3) {
         Y = data[i];
         Cb = data[i + 1];
@@ -916,11 +1136,13 @@ var JpegImage = function JpegImageClosure() {
         data[i + 1] = Y + 135.459 - 0.344 * Cb - 0.714 * Cr;
         data[i + 2] = Y - 226.816 + 1.772 * Cb;
       }
+
       return data;
     },
     _convertYcckToRgb: function convertYcckToRgb(data) {
       var Y, Cb, Cr, k;
       var offset = 0;
+
       for (var i = 0, length = data.length; i < length; i += 4) {
         Y = data[i];
         Cb = data[i + 1];
@@ -930,10 +1152,12 @@ var JpegImage = function JpegImageClosure() {
         data[offset++] = 107.268039397724 + Cb * (2.19927104525741e-5 * Cb - 0.000640992018297945 * Cr + 0.000659397001245577 * Y + 0.000426105652938837 * k - 0.176491792462875) + Cr * (-0.000778269941513683 * Cr + 0.00130872261408275 * Y + 0.000770482631801132 * k - 0.151051492775562) + Y * (0.00126935368114843 * Y - 0.00265090189010898 * k + 0.25802910206845) + k * (-0.000318913117588328 * k - 0.213742400323665);
         data[offset++] = -20.810012546947 + Cb * (-0.000570115196973677 * Cb - 2.63409051004589e-5 * Cr + 0.0020741088115012 * Y - 0.00288260236853442 * k + 0.814272968359295) + Cr * (-1.53496057440975e-5 * Cr - 0.000132689043961446 * Y + 0.000560833691242812 * k - 0.195152027534049) + Y * (0.00174418132927582 * Y - 0.00255243321439347 * k + 0.116935020465145) + k * (-0.000343531996510555 * k + 0.24165260232407);
       }
+
       return data.subarray(0, offset);
     },
     _convertYcckToCmyk: function convertYcckToCmyk(data) {
       var Y, Cb, Cr;
+
       for (var i = 0, length = data.length; i < length; i += 4) {
         Y = data[i];
         Cb = data[i + 1];
@@ -942,12 +1166,14 @@ var JpegImage = function JpegImageClosure() {
         data[i + 1] = 119.541 - Y + 0.344 * Cb + 0.714 * Cr;
         data[i + 2] = 481.816 - Y - 1.772 * Cb;
       }
+
       return data;
     },
     _convertCmykToRgb: function convertCmykToRgb(data) {
       var c, m, y, k;
       var offset = 0;
       var scale = 1 / 255;
+
       for (var i = 0, length = data.length; i < length; i += 4) {
         c = data[i] * scale;
         m = data[i + 1] * scale;
@@ -957,39 +1183,54 @@ var JpegImage = function JpegImageClosure() {
         data[offset++] = 255 + c * (8.841041422036149 * c + 60.118027045597366 * m + 6.871425592049007 * y + 31.159100130055922 * k - 79.2970844816548) + m * (-15.310361306967817 * m + 17.575251261109482 * y + 131.35250912493976 * k - 190.9453302588951) + y * (4.444339102852739 * y + 9.8632861493405 * k - 24.86741582555878) - k * (20.737325471181034 * k + 187.80453709719578);
         data[offset++] = 255 + c * (0.8842522430003296 * c + 8.078677503112928 * m + 30.89978309703729 * y - 0.23883238689178934 * k - 14.183576799673286) + m * (10.49593273432072 * m + 63.02378494754052 * y + 50.606957656360734 * k - 112.23884253719248) + y * (0.03296041114873217 * y + 115.60384449646641 * k - 193.58209356861505) - k * (22.33816807309886 * k + 180.12613974708367);
       }
+
       return data.subarray(0, offset);
     },
-    getData: function getData(width, height, forceRGBoutput) {
+    getData: function getData(_ref3) {
+      var width = _ref3.width,
+          height = _ref3.height,
+          _ref3$forceRGB = _ref3.forceRGB,
+          forceRGB = _ref3$forceRGB === void 0 ? false : _ref3$forceRGB,
+          _ref3$isSourcePDF = _ref3.isSourcePDF,
+          isSourcePDF = _ref3$isSourcePDF === void 0 ? false : _ref3$isSourcePDF;
+
       if (this.numComponents > 4) {
         throw new JpegError('Unsupported color mode');
       }
-      var data = this._getLinearizedBlockData(width, height);
-      if (this.numComponents === 1 && forceRGBoutput) {
+
+      var data = this._getLinearizedBlockData(width, height, isSourcePDF);
+
+      if (this.numComponents === 1 && forceRGB) {
         var dataLength = data.length;
         var rgbData = new Uint8ClampedArray(dataLength * 3);
         var offset = 0;
+
         for (var i = 0; i < dataLength; i++) {
           var grayColor = data[i];
           rgbData[offset++] = grayColor;
           rgbData[offset++] = grayColor;
           rgbData[offset++] = grayColor;
         }
+
         return rgbData;
-      } else if (this.numComponents === 3 && this._isColorConversionNeeded()) {
+      } else if (this.numComponents === 3 && this._isColorConversionNeeded) {
         return this._convertYccToRgb(data);
       } else if (this.numComponents === 4) {
-        if (this._isColorConversionNeeded()) {
-          if (forceRGBoutput) {
+        if (this._isColorConversionNeeded) {
+          if (forceRGB) {
             return this._convertYcckToRgb(data);
           }
+
           return this._convertYcckToCmyk(data);
-        } else if (forceRGBoutput) {
+        } else if (forceRGB) {
           return this._convertCmykToRgb(data);
         }
       }
+
       return data;
     }
   };
   return JpegImage;
 }();
+
 exports.JpegImage = JpegImage;