pdfjs-dist 2.4.456 → 2.5.207

package/lib/core/image.js

@@ -39,17 +39,6 @@ var _jpeg_stream = require("./jpeg_stream.js");
 var _jpx = require("./jpx.js");
 
 var PDFImage = function PDFImageClosure() {
-  function handleImageData(image, nativeDecoder) {
-    if (nativeDecoder && nativeDecoder.canDecode(image)) {
-      return nativeDecoder.decode(image).catch(reason => {
-        (0, _util.warn)("Native image decoding failed -- trying to recover: " + (reason && reason.message));
-        return image;
-      });
-    }
-
-    return Promise.resolve(image);
-  }
-
   function decodeAndClamp(value, addend, coefficient, max) {
     value = addend + value * coefficient;
 
@@ -246,51 +235,37 @@ var PDFImage = function PDFImageClosure() {
   }
 
   PDFImage.buildImage = function ({
-    handler,
     xref,
     res,
     image,
     isInline = false,
-    nativeDecoder = null,
     pdfFunctionFactory
   }) {
-    var imagePromise = handleImageData(image, nativeDecoder);
-    var smaskPromise;
-    var maskPromise;
-    var smask = image.dict.get("SMask");
-    var mask = image.dict.get("Mask");
+    const imageData = image;
+    let smaskData = null;
+    let maskData = null;
+    const smask = image.dict.get("SMask");
+    const mask = image.dict.get("Mask");
 
     if (smask) {
-      smaskPromise = handleImageData(smask, nativeDecoder);
-      maskPromise = Promise.resolve(null);
-    } else {
-      smaskPromise = Promise.resolve(null);
-
-      if (mask) {
-        if ((0, _primitives.isStream)(mask)) {
-          maskPromise = handleImageData(mask, nativeDecoder);
-        } else if (Array.isArray(mask)) {
-          maskPromise = Promise.resolve(mask);
-        } else {
-          (0, _util.warn)("Unsupported mask format.");
-          maskPromise = Promise.resolve(null);
-        }
+      smaskData = smask;
+    } else if (mask) {
+      if ((0, _primitives.isStream)(mask) || Array.isArray(mask)) {
+        maskData = mask;
       } else {
-        maskPromise = Promise.resolve(null);
+        (0, _util.warn)("Unsupported mask format.");
       }
     }
 
-    return Promise.all([imagePromise, smaskPromise, maskPromise]).then(function ([imageData, smaskData, maskData]) {
-      return new PDFImage({
-        xref,
-        res,
-        image: imageData,
-        isInline,
-        smask: smaskData,
-        mask: maskData,
-        pdfFunctionFactory
-      });
-    });
+    return Promise.resolve(new PDFImage({
+      xref,
+      res,
+      image: imageData,
+      isInline,
+      smask: smaskData,
+      mask: maskData,
+      pdfFunctionFactory
+    }));
   };
 
   PDFImage.createMask = function ({

package/lib/core/image_utils.js

@@ -24,71 +24,147 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.NativeImageDecoder = void 0;
-
-var _colorspace = require("./colorspace.js");
-
-var _jpeg_stream = require("./jpeg_stream.js");
-
-var _stream = require("./stream.js");
-
-class NativeImageDecoder {
-  constructor({
-    xref,
-    resources,
-    handler,
-    forceDataSchema = false,
-    pdfFunctionFactory
-  }) {
-    this.xref = xref;
-    this.resources = resources;
-    this.handler = handler;
-    this.forceDataSchema = forceDataSchema;
-    this.pdfFunctionFactory = pdfFunctionFactory;
+exports.GlobalImageCache = exports.LocalImageCache = void 0;
+
+var _util = require("../shared/util.js");
+
+var _primitives = require("./primitives.js");
+
+class LocalImageCache {
+  constructor() {
+    this._nameRefMap = new Map();
+    this._imageMap = new Map();
+    this._imageCache = new _primitives.RefSetCache();
   }
 
-  canDecode(image) {
-    return image instanceof _jpeg_stream.JpegStream && NativeImageDecoder.isDecodable(image, this.xref, this.resources, this.pdfFunctionFactory) && image.maybeValidDimensions;
+  getByName(name) {
+    const ref = this._nameRefMap.get(name);
+
+    if (ref) {
+      return this.getByRef(ref);
+    }
+
+    return this._imageMap.get(name) || null;
   }
 
-  decode(image) {
-    const dict = image.dict;
-    let colorSpace = dict.get("ColorSpace", "CS");
-    colorSpace = _colorspace.ColorSpace.parse(colorSpace, this.xref, this.resources, this.pdfFunctionFactory);
-    return this.handler.sendWithPromise("JpegDecode", [image.getIR(this.forceDataSchema), colorSpace.numComps]).then(function ({
-      data,
-      width,
-      height
-    }) {
-      return new _stream.Stream(data, 0, data.length, dict);
-    });
+  getByRef(ref) {
+    return this._imageCache.get(ref) || null;
   }
 
-  static isSupported(image, xref, res, pdfFunctionFactory) {
-    const dict = image.dict;
+  set(name, ref = null, data) {
+    if (!name) {
+      throw new Error('LocalImageCache.set - expected "name" argument.');
+    }
 
-    if (dict.has("DecodeParms") || dict.has("DP")) {
-      return false;
+    if (ref) {
+      if (this._imageCache.has(ref)) {
+        return;
+      }
+
+      this._nameRefMap.set(name, ref);
+
+      this._imageCache.put(ref, data);
+
+      return;
+    }
+
+    if (this._imageMap.has(name)) {
+      return;
     }
 
-    const cs = _colorspace.ColorSpace.parse(dict.get("ColorSpace", "CS"), xref, res, pdfFunctionFactory);
+    this._imageMap.set(name, data);
+  }
+
+}
+
+exports.LocalImageCache = LocalImageCache;
 
-    return (cs.name === "DeviceGray" || cs.name === "DeviceRGB") && cs.isDefaultDecode(dict.getArray("Decode", "D"));
+class GlobalImageCache {
+  static get NUM_PAGES_THRESHOLD() {
+    return (0, _util.shadow)(this, "NUM_PAGES_THRESHOLD", 2);
   }
 
-  static isDecodable(image, xref, res, pdfFunctionFactory) {
-    const dict = image.dict;
+  static get MAX_IMAGES_TO_CACHE() {
+    return (0, _util.shadow)(this, "MAX_IMAGES_TO_CACHE", 10);
+  }
+
+  constructor() {
+    this._refCache = new _primitives.RefSetCache();
+    this._imageCache = new _primitives.RefSetCache();
+  }
 
-    if (dict.has("DecodeParms") || dict.has("DP")) {
+  shouldCache(ref, pageIndex) {
+    const pageIndexSet = this._refCache.get(ref);
+
+    const numPages = pageIndexSet ? pageIndexSet.size + (pageIndexSet.has(pageIndex) ? 0 : 1) : 1;
+
+    if (numPages < GlobalImageCache.NUM_PAGES_THRESHOLD) {
+      return false;
+    }
+
+    if (!this._imageCache.has(ref) && this._imageCache.size >= GlobalImageCache.MAX_IMAGES_TO_CACHE) {
       return false;
     }
 
-    const cs = _colorspace.ColorSpace.parse(dict.get("ColorSpace", "CS"), xref, res, pdfFunctionFactory);
+    return true;
+  }
+
+  addPageIndex(ref, pageIndex) {
+    let pageIndexSet = this._refCache.get(ref);
+
+    if (!pageIndexSet) {
+      pageIndexSet = new Set();
+
+      this._refCache.put(ref, pageIndexSet);
+    }
+
+    pageIndexSet.add(pageIndex);
+  }
+
+  getData(ref, pageIndex) {
+    if (!this._refCache.has(ref)) {
+      return null;
+    }
+
+    const pageIndexSet = this._refCache.get(ref);
+
+    if (pageIndexSet.size < GlobalImageCache.NUM_PAGES_THRESHOLD) {
+      return null;
+    }
+
+    if (!this._imageCache.has(ref)) {
+      return null;
+    }
+
+    pageIndexSet.add(pageIndex);
+    return this._imageCache.get(ref);
+  }
+
+  setData(ref, data) {
+    if (!this._refCache.has(ref)) {
+      throw new Error('GlobalImageCache.setData - expected "addPageIndex" to have been called.');
+    }
+
+    if (this._imageCache.has(ref)) {
+      return;
+    }
+
+    if (this._imageCache.size >= GlobalImageCache.MAX_IMAGES_TO_CACHE) {
+      (0, _util.info)("GlobalImageCache.setData - ignoring image above MAX_IMAGES_TO_CACHE.");
+      return;
+    }
+
+    this._imageCache.put(ref, data);
+  }
+
+  clear(onlyData = false) {
+    if (!onlyData) {
+      this._refCache.clear();
+    }
 
-    const bpc = dict.get("BitsPerComponent", "BPC") || 1;
-    return (cs.numComps === 1 || cs.numComps === 3) && cs.isDefaultDecode(dict.getArray("Decode", "D"), bpc);
+    this._imageCache.clear();
   }
 
 }
 
-exports.NativeImageDecoder = NativeImageDecoder;
+exports.GlobalImageCache = GlobalImageCache;

package/lib/core/jpeg_stream.js

@@ -26,14 +26,14 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.JpegStream = void 0;
 
-var _util = require("../shared/util.js");
-
 var _stream = require("./stream.js");
 
 var _primitives = require("./primitives.js");
 
 var _jpg = require("./jpg.js");
 
+var _util = require("../shared/util.js");
+
 const JpegStream = function JpegStreamClosure() {
   function JpegStream(stream, maybeLength, dict, params) {
     let ch;
@@ -116,120 +116,6 @@ const JpegStream = function JpegStreamClosure() {
     this.eof = true;
   };
 
-  Object.defineProperty(JpegStream.prototype, "maybeValidDimensions", {
-    get: function JpegStream_maybeValidDimensions() {
-      const {
-        dict,
-        stream
-      } = this;
-      const dictHeight = dict.get("Height", "H");
-      const startPos = stream.pos;
-      let validDimensions = true,
-          foundSOF = false,
-          b;
-
-      while ((b = stream.getByte()) !== -1) {
-        if (b !== 0xff) {
-          continue;
-        }
-
-        switch (stream.getByte()) {
-          case 0xc0:
-          case 0xc1:
-          case 0xc2:
-            foundSOF = true;
-            stream.pos += 2;
-            stream.pos += 1;
-            const scanLines = stream.getUint16();
-
-            if (scanLines === dictHeight) {
-              break;
-            }
-
-            if (scanLines === 0) {
-              validDimensions = false;
-              break;
-            }
-
-            if (scanLines > dictHeight * 10) {
-              validDimensions = false;
-              break;
-            }
-
-            break;
-
-          case 0xc3:
-          case 0xc5:
-          case 0xc6:
-          case 0xc7:
-          case 0xc9:
-          case 0xca:
-          case 0xcb:
-          case 0xcd:
-          case 0xce:
-          case 0xcf:
-            foundSOF = true;
-            break;
-
-          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:
-            const markerLength = stream.getUint16();
-
-            if (markerLength > 2) {
-              stream.skip(markerLength - 2);
-            } else {
-              stream.skip(-2);
-            }
-
-            break;
-
-          case 0xff:
-            stream.skip(-1);
-            break;
-
-          case 0xd9:
-            foundSOF = true;
-            break;
-        }
-
-        if (foundSOF) {
-          break;
-        }
-      }
-
-      stream.pos = startPos;
-      return (0, _util.shadow)(this, "maybeValidDimensions", validDimensions);
-    },
-    configurable: true
-  });
-
-  JpegStream.prototype.getIR = function (forceDataSchema = false) {
-    return (0, _util.createObjectURL)(this.bytes, "image/jpeg", forceDataSchema);
-  };
-
   return JpegStream;
 }();
 

package/lib/core/jpg.js

@@ -128,8 +128,8 @@ var JpegImage = function JpegImageClosure() {
   function decodeScan(data, offset, frame, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive, parseDNLMarker = false) {
     var mcusPerLine = frame.mcusPerLine;
     var progressive = frame.progressive;
-    var startOffset = offset,
-        bitsData = 0,
+    const startOffset = offset;
+    let bitsData = 0,
         bitsCount = 0;
 
     function readBit() {
@@ -215,10 +215,10 @@ var JpegImage = function JpegImageClosure() {
       return n + (-1 << length) + 1;
     }
 
-    function decodeBaseline(component, offset) {
+    function decodeBaseline(component, blockOffset) {
       var t = decodeHuffman(component.huffmanTableDC);
       var diff = t === 0 ? 0 : receiveAndExtend(t);
-      component.blockData[offset] = component.pred += diff;
+      component.blockData[blockOffset] = component.pred += diff;
       var k = 1;
 
       while (k < 64) {
@@ -237,24 +237,24 @@ var JpegImage = function JpegImageClosure() {
 
         k += r;
         var z = dctZigZag[k];
-        component.blockData[offset + z] = receiveAndExtend(s);
+        component.blockData[blockOffset + z] = receiveAndExtend(s);
         k++;
       }
     }
 
-    function decodeDCFirst(component, offset) {
+    function decodeDCFirst(component, blockOffset) {
       var t = decodeHuffman(component.huffmanTableDC);
       var diff = t === 0 ? 0 : receiveAndExtend(t) << successive;
-      component.blockData[offset] = component.pred += diff;
+      component.blockData[blockOffset] = component.pred += diff;
     }
 
-    function decodeDCSuccessive(component, offset) {
-      component.blockData[offset] |= readBit() << successive;
+    function decodeDCSuccessive(component, blockOffset) {
+      component.blockData[blockOffset] |= readBit() << successive;
     }
 
     var eobrun = 0;
 
-    function decodeACFirst(component, offset) {
+    function decodeACFirst(component, blockOffset) {
       if (eobrun > 0) {
         eobrun--;
         return;
@@ -280,7 +280,7 @@ var JpegImage = function JpegImageClosure() {
 
         k += r;
         var z = dctZigZag[k];
-        component.blockData[offset + z] = receiveAndExtend(s) * (1 << successive);
+        component.blockData[blockOffset + z] = receiveAndExtend(s) * (1 << successive);
         k++;
       }
     }
@@ -288,7 +288,7 @@ var JpegImage = function JpegImageClosure() {
     var successiveACState = 0,
         successiveACNextValue;
 
-    function decodeACSuccessive(component, offset) {
+    function decodeACSuccessive(component, blockOffset) {
       var k = spectralStart;
       var e = spectralEnd;
       var r = 0;
@@ -296,7 +296,7 @@ var JpegImage = function JpegImageClosure() {
       var rs;
 
       while (k <= e) {
-        const offsetZ = offset + dctZigZag[k];
+        const offsetZ = blockOffset + dctZigZag[k];
         const sign = component.blockData[offsetZ] < 0 ? -1 : 1;
 
         switch (successiveACState) {
@@ -375,15 +375,15 @@ var JpegImage = function JpegImageClosure() {
       var mcuCol = mcu % mcusPerLine;
       blockRow = mcuRow * component.v + row;
       var blockCol = mcuCol * component.h + col;
-      var offset = getBlockBufferOffset(component, blockRow, blockCol);
-      decode(component, offset);
+      const blockOffset = getBlockBufferOffset(component, blockRow, blockCol);
+      decode(component, blockOffset);
     }
 
     function decodeBlock(component, decode, mcu) {
       blockRow = mcu / component.blocksPerLine | 0;
       var blockCol = mcu % component.blocksPerLine;
-      var offset = getBlockBufferOffset(component, blockRow, blockCol);
-      decode(component, offset);
+      const blockOffset = getBlockBufferOffset(component, blockRow, blockCol);
+      decode(component, blockOffset);
     }
 
     var componentsLength = components.length;
@@ -412,37 +412,39 @@ var JpegImage = function JpegImageClosure() {
 
     var h, v;
 
-    while (mcu < mcuExpected) {
+    while (mcu <= mcuExpected) {
       var mcuToRead = resetInterval ? Math.min(mcuExpected - mcu, resetInterval) : mcuExpected;
 
-      for (i = 0; i < componentsLength; i++) {
-        components[i].pred = 0;
-      }
+      if (mcuToRead > 0) {
+        for (i = 0; i < componentsLength; i++) {
+          components[i].pred = 0;
+        }
 
-      eobrun = 0;
+        eobrun = 0;
 
-      if (componentsLength === 1) {
-        component = components[0];
+        if (componentsLength === 1) {
+          component = components[0];
 
-        for (n = 0; n < mcuToRead; n++) {
-          decodeBlock(component, decodeFn, mcu);
-          mcu++;
-        }
-      } else {
-        for (n = 0; n < mcuToRead; n++) {
-          for (i = 0; i < componentsLength; i++) {
-            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);
+          for (n = 0; n < mcuToRead; n++) {
+            decodeBlock(component, decodeFn, mcu);
+            mcu++;
+          }
+        } else {
+          for (n = 0; n < mcuToRead; n++) {
+            for (i = 0; i < componentsLength; i++) {
+              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++;
+            mcu++;
+          }
         }
       }
 
@@ -451,31 +453,21 @@ var JpegImage = function JpegImageClosure() {
 
       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("decodeScan - a valid marker was not found.");
+      if (fileMarker.invalid) {
+        const partialMsg = mcuToRead > 0 ? "unexpected" : "excessive";
+        (0, _util.warn)(`decodeScan - ${partialMsg} MCU data, current marker is: ${fileMarker.invalid}`);
+        offset = fileMarker.offset;
       }
 
-      if (marker >= 0xffd0 && marker <= 0xffd7) {
+      if (fileMarker.marker >= 0xffd0 && fileMarker.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;
   }
 

package/lib/core/jpx.js

@@ -785,7 +785,7 @@ var JpxImage = function JpxImageClosure() {
     var maxDecompositionLevelsCount = 0;
 
     for (c = 0; c < componentsCount; c++) {
-      var component = tile.components[c];
+      const component = tile.components[c];
       maxDecompositionLevelsCount = Math.max(maxDecompositionLevelsCount, component.codingStyleParameters.decompositionLevelsCount);
     }
 
@@ -814,7 +814,7 @@ var JpxImage = function JpxImageClosure() {
       for (; r <= maxDecompositionLevelsCount; r++) {
         for (; p < maxNumPrecinctsInLevel[r]; p++) {
           for (; c < componentsCount; c++) {
-            var component = tile.components[c];
+            const component = tile.components[c];
 
             if (r > component.codingStyleParameters.decompositionLevelsCount) {
               continue;
@@ -1233,13 +1233,13 @@ var JpxImage = function JpxImageClosure() {
         var firstTimeInclusion = false;
         var valueReady;
 
-        if (codeblock["included"] !== undefined) {
+        if (codeblock.included !== undefined) {
           codeblockIncluded = !!readBits(1);
         } else {
           precinct = codeblock.precinct;
           var inclusionTree, zeroBitPlanesTree;
 
-          if (precinct["inclusionTree"] !== undefined) {
+          if (precinct.inclusionTree !== undefined) {
             inclusionTree = precinct.inclusionTree;
           } else {
             var width = precinct.cbxMax - precinct.cbxMin + 1;
@@ -1317,7 +1317,7 @@ var JpxImage = function JpxImageClosure() {
         var packetItem = queue.shift();
         codeblock = packetItem.codeblock;
 
-        if (codeblock["data"] === undefined) {
+        if (codeblock.data === undefined) {
           codeblock.data = [];
         }
 
@@ -1351,7 +1351,7 @@ var JpxImage = function JpxImageClosure() {
         continue;
       }
 
-      if (codeblock["data"] === undefined) {
+      if (codeblock.data === undefined) {
         continue;
       }