pdfjs-dist 2.4.456 → 2.5.207

package/lib/core/evaluator.js

@@ -58,24 +58,21 @@ var _metrics = require("./metrics.js");
 
 var _function = require("./function.js");
 
-var _jpeg_stream = require("./jpeg_stream.js");
+var _image_utils = require("./image_utils.js");
 
 var _murmurhash = require("./murmurhash3.js");
 
-var _image_utils = require("./image_utils.js");
-
 var _operator_list = require("./operator_list.js");
 
 var _image = require("./image.js");
 
 var PartialEvaluator = function PartialEvaluatorClosure() {
   const DefaultPartialEvaluatorOptions = {
-    forceDataSchema: false,
     maxImageSize: -1,
     disableFontFace: false,
-    nativeImageDecoderSupport: _util.NativeImageDecoding.DECODE,
     ignoreErrors: false,
-    isEvalSupported: true
+    isEvalSupported: true,
+    fontExtraProperties: false
   };
 
   function PartialEvaluator({
@@ -85,6 +82,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
     idFactory,
     fontCache,
     builtInCMapCache,
+    globalImageCache,
     options = null,
     pdfFunctionFactory
   }) {
@@ -94,6 +92,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
     this.idFactory = idFactory;
     this.fontCache = fontCache;
     this.builtInCMapCache = builtInCMapCache;
+    this.globalImageCache = globalImageCache;
     this.options = options || DefaultPartialEvaluatorOptions;
     this.pdfFunctionFactory = pdfFunctionFactory;
     this.parsingType3Font = false;
@@ -289,7 +288,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
                   }
 
                   this.handler.send("UnsupportedFeature", {
-                    featureId: _util.UNSUPPORTED_FEATURES.unknown
+                    featureId: _util.UNSUPPORTED_FEATURES.errorExtGState
                   });
                   (0, _util.warn)(`hasBlendModes - ignoring ExtGState: "${ex}".`);
                   continue;
@@ -357,7 +356,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
                 }
 
                 this.handler.send("UnsupportedFeature", {
-                  featureId: _util.UNSUPPORTED_FEATURES.unknown
+                  featureId: _util.UNSUPPORTED_FEATURES.errorXObject
                 });
                 (0, _util.warn)(`hasBlendModes - ignoring XObject: "${ex}".`);
                 continue;
@@ -460,10 +459,10 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
       isInline = false,
       operatorList,
       cacheKey,
-      imageCache,
-      forceDisableNativeImageDecoder = false
+      localImageCache
     }) {
       var dict = image.dict;
+      const imageRef = dict.objId;
       var w = dict.get("Width", "W");
       var h = dict.get("Height", "H");
 
@@ -500,10 +499,10 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
         operatorList.addOp(_util.OPS.paintImageMaskXObject, args);
 
         if (cacheKey) {
-          imageCache[cacheKey] = {
+          localImageCache.set(cacheKey, imageRef, {
             fn: _util.OPS.paintImageMaskXObject,
             args
-          };
+          });
         }
 
         return undefined;
@@ -513,7 +512,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
       var mask = dict.get("Mask") || false;
       var SMALL_IMAGE_DIMENSIONS = 200;
 
-      if (isInline && !softMask && !mask && !(image instanceof _jpeg_stream.JpegStream) && w + h < SMALL_IMAGE_DIMENSIONS) {
+      if (isInline && !softMask && !mask && w + h < SMALL_IMAGE_DIMENSIONS) {
         const imageObj = new _image.PDFImage({
           xref: this.xref,
           res: resources,
@@ -526,68 +525,36 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
         return undefined;
       }
 
-      const nativeImageDecoderSupport = forceDisableNativeImageDecoder ? _util.NativeImageDecoding.NONE : this.options.nativeImageDecoderSupport;
-      let objId = `img_${this.idFactory.createObjId()}`;
+      let objId = `img_${this.idFactory.createObjId()}`,
+          cacheGlobally = false;
 
       if (this.parsingType3Font) {
-        (0, _util.assert)(nativeImageDecoderSupport === _util.NativeImageDecoding.NONE, "Type3 image resources should be completely decoded in the worker.");
         objId = `${this.idFactory.getDocId()}_type3res_${objId}`;
-      }
-
-      if (nativeImageDecoderSupport !== _util.NativeImageDecoding.NONE && !softMask && !mask && image instanceof _jpeg_stream.JpegStream && _image_utils.NativeImageDecoder.isSupported(image, this.xref, resources, this.pdfFunctionFactory) && image.maybeValidDimensions) {
-        return this.handler.sendWithPromise("obj", [objId, this.pageIndex, "JpegStream", image.getIR(this.options.forceDataSchema)]).then(function () {
-          operatorList.addDependency(objId);
-          args = [objId, w, h];
-          operatorList.addOp(_util.OPS.paintJpegXObject, args);
-
-          if (cacheKey) {
-            imageCache[cacheKey] = {
-              fn: _util.OPS.paintJpegXObject,
-              args
-            };
-          }
-        }, reason => {
-          (0, _util.warn)("Native JPEG decoding failed -- trying to recover: " + (reason && reason.message));
-          return this.buildPaintImageXObject({
-            resources,
-            image,
-            isInline,
-            operatorList,
-            cacheKey,
-            imageCache,
-            forceDisableNativeImageDecoder: true
-          });
-        });
-      }
-
-      var nativeImageDecoder = null;
+      } else if (imageRef) {
+        cacheGlobally = this.globalImageCache.shouldCache(imageRef, this.pageIndex);
 
-      if (nativeImageDecoderSupport === _util.NativeImageDecoding.DECODE && (image instanceof _jpeg_stream.JpegStream || mask instanceof _jpeg_stream.JpegStream || softMask instanceof _jpeg_stream.JpegStream)) {
-        nativeImageDecoder = new _image_utils.NativeImageDecoder({
-          xref: this.xref,
-          resources,
-          handler: this.handler,
-          forceDataSchema: this.options.forceDataSchema,
-          pdfFunctionFactory: this.pdfFunctionFactory
-        });
+        if (cacheGlobally) {
+          objId = `${this.idFactory.getDocId()}_${objId}`;
+        }
       }
 
       operatorList.addDependency(objId);
       args = [objId, w, h];
 
       const imgPromise = _image.PDFImage.buildImage({
-        handler: this.handler,
         xref: this.xref,
         res: resources,
         image,
         isInline,
-        nativeDecoder: nativeImageDecoder,
         pdfFunctionFactory: this.pdfFunctionFactory
       }).then(imageObj => {
-        var imgData = imageObj.createImageData(false);
+        imgData = imageObj.createImageData(false);
 
         if (this.parsingType3Font) {
           return this.handler.sendWithPromise("commonobj", [objId, "FontType3Res", imgData], [imgData.data.buffer]);
+        } else if (cacheGlobally) {
+          this.handler.send("commonobj", [objId, "Image", imgData], [imgData.data.buffer]);
+          return undefined;
         }
 
         this.handler.send("obj", [objId, this.pageIndex, "Image", imgData], [imgData.data.buffer]);
@@ -597,6 +564,9 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
 
         if (this.parsingType3Font) {
           return this.handler.sendWithPromise("commonobj", [objId, "FontType3Res", null]);
+        } else if (cacheGlobally) {
+          this.handler.send("commonobj", [objId, "Image", null]);
+          return undefined;
         }
 
         this.handler.send("obj", [objId, this.pageIndex, "Image", null]);
@@ -610,10 +580,23 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
       operatorList.addOp(_util.OPS.paintImageXObject, args);
 
       if (cacheKey) {
-        imageCache[cacheKey] = {
+        localImageCache.set(cacheKey, imageRef, {
           fn: _util.OPS.paintImageXObject,
           args
-        };
+        });
+
+        if (imageRef) {
+          (0, _util.assert)(!isInline, "Cannot cache an inline image globally.");
+          this.globalImageCache.addPageIndex(imageRef, this.pageIndex);
+
+          if (cacheGlobally) {
+            this.globalImageCache.setData(imageRef, {
+              objId,
+              fn: _util.OPS.paintImageXObject,
+              args
+            });
+          }
+        }
       }
 
       return undefined;
@@ -670,7 +653,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
 
         if (this.options.ignoreErrors) {
           this.handler.send("UnsupportedFeature", {
-            featureId: _util.UNSUPPORTED_FEATURES.unknown
+            featureId: _util.UNSUPPORTED_FEATURES.errorTilingPattern
           });
           (0, _util.warn)(`handleTilingType - ignoring pattern: "${reason}".`);
           return;
@@ -697,9 +680,14 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
           return translated;
         }).catch(reason => {
           this.handler.send("UnsupportedFeature", {
-            featureId: _util.UNSUPPORTED_FEATURES.font
+            featureId: _util.UNSUPPORTED_FEATURES.errorFontLoadType3
+          });
+          return new TranslatedFont({
+            loadedName: "g_font_error",
+            font: new _fonts.ErrorFont(`Type3 font load error: ${reason}`),
+            dict: translated.font,
+            extraProperties: this.options.fontExtraProperties
           });
-          return new TranslatedFont("g_font_error", new _fonts.ErrorFont("Type3 font load error: " + reason), translated.font);
         });
       }).then(translated => {
         state.font = translated.font;
@@ -732,7 +720,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
 
       if (this.options.ignoreErrors) {
         this.handler.send("UnsupportedFeature", {
-          featureId: _util.UNSUPPORTED_FEATURES.font
+          featureId: _util.UNSUPPORTED_FEATURES.errorFontState
         });
         (0, _util.warn)(`ensureStateFont: "${reason}".`);
         return;
@@ -826,9 +814,14 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
       });
     },
     loadFont: function PartialEvaluator_loadFont(fontName, font, resources) {
-      function errorFont() {
-        return Promise.resolve(new TranslatedFont("g_font_error", new _fonts.ErrorFont("Font " + fontName + " is not available"), font));
-      }
+      const errorFont = () => {
+        return Promise.resolve(new TranslatedFont({
+          loadedName: "g_font_error",
+          font: new _fonts.ErrorFont(`Font "${fontName}" is not available.`),
+          dict: font,
+          extraProperties: this.options.fontExtraProperties
+        }));
+      };
 
       var fontRef,
           xref = this.xref;
@@ -856,7 +849,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
         }
 
         this.handler.send("UnsupportedFeature", {
-          featureId: _util.UNSUPPORTED_FEATURES.font
+          featureId: _util.UNSUPPORTED_FEATURES.errorFontMissing
         });
         (0, _util.warn)(`${partialMsg} -- attempting to fallback to a default font.`);
         fontRef = PartialEvaluator.getFallbackFontDict();
@@ -937,16 +930,21 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
         translatedPromise = Promise.reject(e);
       }
 
-      translatedPromise.then(function (translatedFont) {
+      translatedPromise.then(translatedFont => {
         if (translatedFont.fontType !== undefined) {
           var xrefFontStats = xref.stats.fontTypes;
           xrefFontStats[translatedFont.fontType] = true;
         }
 
-        fontCapability.resolve(new TranslatedFont(font.loadedName, translatedFont, font));
+        fontCapability.resolve(new TranslatedFont({
+          loadedName: font.loadedName,
+          font: translatedFont,
+          dict: font,
+          extraProperties: this.options.fontExtraProperties
+        }));
       }).catch(reason => {
         this.handler.send("UnsupportedFeature", {
-          featureId: _util.UNSUPPORTED_FEATURES.font
+          featureId: _util.UNSUPPORTED_FEATURES.errorFontTranslate
         });
 
         try {
@@ -957,7 +955,12 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
           xrefFontStats[fontType] = true;
         } catch (ex) {}
 
-        fontCapability.resolve(new TranslatedFont(font.loadedName, new _fonts.ErrorFont(reason instanceof Error ? reason.message : reason), font));
+        fontCapability.resolve(new TranslatedFont({
+          loadedName: font.loadedName,
+          font: new _fonts.ErrorFont(reason instanceof Error ? reason.message : reason),
+          dict: font,
+          extraProperties: this.options.fontExtraProperties
+        }));
       });
       return fontCapability.promise;
     },
@@ -1000,7 +1003,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
 
         if (this.options.ignoreErrors) {
           this.handler.send("UnsupportedFeature", {
-            featureId: _util.UNSUPPORTED_FEATURES.unknown
+            featureId: _util.UNSUPPORTED_FEATURES.errorColorSpace
           });
           (0, _util.warn)(`parseColorSpace - ignoring ColorSpace: "${reason}".`);
           return null;
@@ -1052,7 +1055,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
       var self = this;
       var xref = this.xref;
       let parsingText = false;
-      var imageCache = Object.create(null);
+      const localImageCache = new _image_utils.LocalImageCache();
 
       var xobjs = resources.get("XObject") || _primitives.Dict.empty;
 
@@ -1101,10 +1104,14 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
             case _util.OPS.paintXObject:
               var name = args[0].name;
 
-              if (name && imageCache[name] !== undefined) {
-                operatorList.addOp(imageCache[name].fn, imageCache[name].args);
-                args = null;
-                continue;
+              if (name) {
+                const localImage = localImageCache.getByName(name);
+
+                if (localImage) {
+                  operatorList.addOp(localImage.fn, localImage.args);
+                  args = null;
+                  continue;
+                }
               }
 
               next(new Promise(function (resolveXObject, rejectXObject) {
@@ -1112,7 +1119,28 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
                   throw new _util.FormatError("XObject must be referred to by name.");
                 }
 
-                const xobj = xobjs.get(name);
+                let xobj = xobjs.getRaw(name);
+
+                if (xobj instanceof _primitives.Ref) {
+                  const localImage = localImageCache.getByRef(xobj);
+
+                  if (localImage) {
+                    operatorList.addOp(localImage.fn, localImage.args);
+                    resolveXObject();
+                    return;
+                  }
+
+                  const globalImage = self.globalImageCache.getData(xobj, self.pageIndex);
+
+                  if (globalImage) {
+                    operatorList.addDependency(globalImage.objId);
+                    operatorList.addOp(globalImage.fn, globalImage.args);
+                    resolveXObject();
+                    return;
+                  }
+
+                  xobj = xref.fetch(xobj);
+                }
 
                 if (!xobj) {
                   operatorList.addOp(fn, args);
@@ -1143,7 +1171,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
                     image: xobj,
                     operatorList,
                     cacheKey: name,
-                    imageCache
+                    localImageCache
                   }).then(resolveXObject, rejectXObject);
                   return;
                 } else if (type.name === "PS") {
@@ -1160,7 +1188,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
 
                 if (self.options.ignoreErrors) {
                   self.handler.send("UnsupportedFeature", {
-                    featureId: _util.UNSUPPORTED_FEATURES.unknown
+                    featureId: _util.UNSUPPORTED_FEATURES.errorXObject
                   });
                   (0, _util.warn)(`getOperatorList - ignoring XObject: "${reason}".`);
                   return;
@@ -1190,10 +1218,10 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
               var cacheKey = args[0].cacheKey;
 
               if (cacheKey) {
-                var cacheEntry = imageCache[cacheKey];
+                const localImage = localImageCache.getByName(cacheKey);
 
-                if (cacheEntry !== undefined) {
-                  operatorList.addOp(cacheEntry.fn, cacheEntry.args);
+                if (localImage) {
+                  operatorList.addOp(localImage.fn, localImage.args);
                   args = null;
                   continue;
                 }
@@ -1205,7 +1233,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
                 isInline: true,
                 operatorList,
                 cacheKey,
-                imageCache
+                localImageCache
               }));
               return;
 
@@ -1447,7 +1475,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
 
         if (this.options.ignoreErrors) {
           this.handler.send("UnsupportedFeature", {
-            featureId: _util.UNSUPPORTED_FEATURES.unknown
+            featureId: _util.UNSUPPORTED_FEATURES.errorOperatorList
           });
           (0, _util.warn)(`getOperatorList - ignoring errors during "${task.name}" ` + `task: "${reason}".`);
           closePendingRestoreOPS();
@@ -1498,7 +1526,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
       var self = this;
       var xref = this.xref;
       var xobjs = null;
-      var skipEmptyXObjs = Object.create(null);
+      const emptyXObjectCache = new _image_utils.LocalImageCache();
       var preprocessor = new EvaluatorPreprocessor(stream, xref, stateManager);
       var textState;
 
@@ -1515,7 +1543,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
             fontFamily: font.fallbackName,
             ascent: font.ascent,
             descent: font.descent,
-            vertical: !!font.vertical
+            vertical: font.vertical
           };
         }
 
@@ -1923,7 +1951,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
 
               var name = args[0].name;
 
-              if (name && skipEmptyXObjs[name] !== undefined) {
+              if (name && emptyXObjectCache.getByName(name)) {
                 break;
               }
 
@@ -1932,7 +1960,16 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
                   throw new _util.FormatError("XObject must be referred to by name.");
                 }
 
-                const xobj = xobjs.get(name);
+                let xobj = xobjs.getRaw(name);
+
+                if (xobj instanceof _primitives.Ref) {
+                  if (emptyXObjectCache.getByRef(xobj)) {
+                    resolveXObject();
+                    return;
+                  }
+
+                  xobj = xref.fetch(xobj);
+                }
 
                 if (!xobj) {
                   resolveXObject();
@@ -1950,7 +1987,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
                 }
 
                 if (type.name !== "Form") {
-                  skipEmptyXObjs[name] = true;
+                  emptyXObjectCache.set(name, xobj.dict.objId, true);
                   resolveXObject();
                   return;
                 }
@@ -1992,7 +2029,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
                   seenStyles
                 }).then(function () {
                   if (!sinkWrapper.enqueueInvoked) {
-                    skipEmptyXObjs[name] = true;
+                    emptyXObjectCache.set(name, xobj.dict.objId, true);
                   }
 
                   resolveXObject();
@@ -2160,14 +2197,14 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
       properties.baseEncodingName = baseEncodingName;
       properties.hasEncoding = !!baseEncodingName || differences.length > 0;
       properties.dict = dict;
-      return toUnicodePromise.then(toUnicode => {
-        properties.toUnicode = toUnicode;
+      return toUnicodePromise.then(readToUnicode => {
+        properties.toUnicode = readToUnicode;
         return this.buildToUnicode(properties);
-      }).then(toUnicode => {
-        properties.toUnicode = toUnicode;
+      }).then(builtToUnicode => {
+        properties.toUnicode = builtToUnicode;
 
         if (cidToGidBytes) {
-          properties.cidToGidMap = this.readCidToGidMap(cidToGidBytes, toUnicode);
+          properties.cidToGidMap = this.readCidToGidMap(cidToGidBytes, builtToUnicode);
         }
 
         return properties;
@@ -2244,7 +2281,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
 
           }
 
-          if (code > 0 && Number.isInteger(code)) {
+          if (code > 0 && code <= 0x10ffff && Number.isInteger(code)) {
             if (baseEncodingName && code === +charcode) {
               const baseEncoding = (0, _encodings.getEncoding)(baseEncodingName);
 
@@ -2364,7 +2401,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
 
           if (this.options.ignoreErrors) {
             this.handler.send("UnsupportedFeature", {
-              featureId: _util.UNSUPPORTED_FEATURES.font
+              featureId: _util.UNSUPPORTED_FEATURES.errorFontToUnicode
             });
             (0, _util.warn)(`readToUnicode - ignoring ToUnicode data: "${reason}".`);
             return null;
@@ -2690,7 +2727,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
             lastChar
           };
           const widths = dict.get("Widths");
-          return this.extractDataStructures(dict, dict, properties).then(properties => {
+          return this.extractDataStructures(dict, dict, properties).then(newProperties => {
             if (widths) {
               const glyphWidths = [];
               let j = firstChar;
@@ -2699,12 +2736,12 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
                 glyphWidths[j++] = this.xref.fetchIfRef(widths[i]);
               }
 
-              properties.widths = glyphWidths;
+              newProperties.widths = glyphWidths;
             } else {
-              properties.widths = this.buildCharCodeToWidth(metrics.widths, properties);
+              newProperties.widths = this.buildCharCodeToWidth(metrics.widths, newProperties);
             }
 
-            return new _fonts.Font(baseFontName, null, properties);
+            return new _fonts.Font(baseFontName, null, newProperties);
           });
         }
       }
@@ -2765,7 +2802,6 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
         length3,
         loadedName: baseDict.loadedName,
         composite,
-        wideChars: composite,
         fixedPitch: false,
         fontMatrix: dict.getArray("FontMatrix") || _util.FONT_IDENTITY_MATRIX,
         firstChar: firstChar || 0,
@@ -2802,14 +2838,14 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
 
       return cMapPromise.then(() => {
         return this.extractDataStructures(dict, baseDict, properties);
-      }).then(properties => {
-        this.extractWidths(dict, descriptor, properties);
+      }).then(newProperties => {
+        this.extractWidths(dict, descriptor, newProperties);
 
         if (type === "Type3") {
-          properties.isType3Font = true;
+          newProperties.isType3Font = true;
         }
 
-        return new _fonts.Font(fontName.name, fontFile, properties);
+        return new _fonts.Font(fontName.name, fontFile, newProperties);
       });
     }
   };
@@ -2851,86 +2887,88 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
 
 exports.PartialEvaluator = PartialEvaluator;
 
-var TranslatedFont = function TranslatedFontClosure() {
-  function TranslatedFont(loadedName, font, dict) {
+class TranslatedFont {
+  constructor({
+    loadedName,
+    font,
+    dict,
+    extraProperties = false
+  }) {
     this.loadedName = loadedName;
     this.font = font;
     this.dict = dict;
+    this._extraProperties = extraProperties;
     this.type3Loaded = null;
     this.sent = false;
   }
 
-  TranslatedFont.prototype = {
-    send(handler) {
-      if (this.sent) {
-        return;
-      }
+  send(handler) {
+    if (this.sent) {
+      return;
+    }
 
-      this.sent = true;
-      handler.send("commonobj", [this.loadedName, "Font", this.font.exportData()]);
-    },
+    this.sent = true;
+    handler.send("commonobj", [this.loadedName, "Font", this.font.exportData(this._extraProperties)]);
+  }
 
-    fallback(handler) {
-      if (!this.font.data) {
-        return;
-      }
+  fallback(handler) {
+    if (!this.font.data) {
+      return;
+    }
 
-      this.font.disableFontFace = true;
-      const glyphs = this.font.glyphCacheValues;
-      PartialEvaluator.buildFontPaths(this.font, glyphs, handler);
-    },
+    this.font.disableFontFace = true;
+    const glyphs = this.font.glyphCacheValues;
+    PartialEvaluator.buildFontPaths(this.font, glyphs, handler);
+  }
 
-    loadType3Data(evaluator, resources, parentOperatorList, task) {
-      if (!this.font.isType3Font) {
-        throw new Error("Must be a Type3 font.");
-      }
-
-      if (this.type3Loaded) {
-        return this.type3Loaded;
-      }
-
-      var type3Options = Object.create(evaluator.options);
-      type3Options.ignoreErrors = false;
-      type3Options.nativeImageDecoderSupport = _util.NativeImageDecoding.NONE;
-      var type3Evaluator = evaluator.clone(type3Options);
-      type3Evaluator.parsingType3Font = true;
-      var translatedFont = this.font;
-      var loadCharProcsPromise = Promise.resolve();
-      var charProcs = this.dict.get("CharProcs");
-      var fontResources = this.dict.get("Resources") || resources;
-      var charProcKeys = charProcs.getKeys();
-      var charProcOperatorList = Object.create(null);
-
-      for (var i = 0, n = charProcKeys.length; i < n; ++i) {
-        const key = charProcKeys[i];
-        loadCharProcsPromise = loadCharProcsPromise.then(function () {
-          var glyphStream = charProcs.get(key);
-          var operatorList = new _operator_list.OperatorList();
-          return type3Evaluator.getOperatorList({
-            stream: glyphStream,
-            task,
-            resources: fontResources,
-            operatorList
-          }).then(function () {
-            charProcOperatorList[key] = operatorList.getIR();
-            parentOperatorList.addDependencies(operatorList.dependencies);
-          }).catch(function (reason) {
-            (0, _util.warn)(`Type3 font resource "${key}" is not available.`);
-            var operatorList = new _operator_list.OperatorList();
-            charProcOperatorList[key] = operatorList.getIR();
-          });
-        });
-      }
+  loadType3Data(evaluator, resources, parentOperatorList, task) {
+    if (!this.font.isType3Font) {
+      throw new Error("Must be a Type3 font.");
+    }
 
-      this.type3Loaded = loadCharProcsPromise.then(function () {
-        translatedFont.charProcOperatorList = charProcOperatorList;
-      });
+    if (this.type3Loaded) {
       return this.type3Loaded;
     }
 
-  };
-  return TranslatedFont;
-}();
+    var type3Options = Object.create(evaluator.options);
+    type3Options.ignoreErrors = false;
+    var type3Evaluator = evaluator.clone(type3Options);
+    type3Evaluator.parsingType3Font = true;
+    var translatedFont = this.font;
+    var loadCharProcsPromise = Promise.resolve();
+    var charProcs = this.dict.get("CharProcs");
+    var fontResources = this.dict.get("Resources") || resources;
+    var charProcKeys = charProcs.getKeys();
+    var charProcOperatorList = Object.create(null);
+
+    for (var i = 0, n = charProcKeys.length; i < n; ++i) {
+      const key = charProcKeys[i];
+      loadCharProcsPromise = loadCharProcsPromise.then(function () {
+        var glyphStream = charProcs.get(key);
+        var operatorList = new _operator_list.OperatorList();
+        return type3Evaluator.getOperatorList({
+          stream: glyphStream,
+          task,
+          resources: fontResources,
+          operatorList
+        }).then(function () {
+          charProcOperatorList[key] = operatorList.getIR();
+          parentOperatorList.addDependencies(operatorList.dependencies);
+        }).catch(function (reason) {
+          (0, _util.warn)(`Type3 font resource "${key}" is not available.`);
+          const dummyOperatorList = new _operator_list.OperatorList();
+          charProcOperatorList[key] = dummyOperatorList.getIR();
+        });
+      });
+    }
+
+    this.type3Loaded = loadCharProcsPromise.then(function () {
+      translatedFont.charProcOperatorList = charProcOperatorList;
+    });
+    return this.type3Loaded;
+  }
+
+}
 
 var StateManager = function StateManagerClosure() {
   function StateManager(initialState) {
@@ -3082,112 +3120,112 @@ var EvalState = function EvalStateClosure() {
 
 var EvaluatorPreprocessor = function EvaluatorPreprocessorClosure() {
   var getOPMap = (0, _core_utils.getLookupTableFactory)(function (t) {
-    t["w"] = {
+    t.w = {
       id: _util.OPS.setLineWidth,
       numArgs: 1,
       variableArgs: false
     };
-    t["J"] = {
+    t.J = {
       id: _util.OPS.setLineCap,
       numArgs: 1,
       variableArgs: false
     };
-    t["j"] = {
+    t.j = {
       id: _util.OPS.setLineJoin,
       numArgs: 1,
       variableArgs: false
     };
-    t["M"] = {
+    t.M = {
       id: _util.OPS.setMiterLimit,
       numArgs: 1,
       variableArgs: false
     };
-    t["d"] = {
+    t.d = {
       id: _util.OPS.setDash,
       numArgs: 2,
       variableArgs: false
     };
-    t["ri"] = {
+    t.ri = {
       id: _util.OPS.setRenderingIntent,
       numArgs: 1,
       variableArgs: false
     };
-    t["i"] = {
+    t.i = {
       id: _util.OPS.setFlatness,
       numArgs: 1,
       variableArgs: false
     };
-    t["gs"] = {
+    t.gs = {
       id: _util.OPS.setGState,
       numArgs: 1,
       variableArgs: false
     };
-    t["q"] = {
+    t.q = {
       id: _util.OPS.save,
       numArgs: 0,
       variableArgs: false
     };
-    t["Q"] = {
+    t.Q = {
       id: _util.OPS.restore,
       numArgs: 0,
       variableArgs: false
     };
-    t["cm"] = {
+    t.cm = {
       id: _util.OPS.transform,
       numArgs: 6,
       variableArgs: false
     };
-    t["m"] = {
+    t.m = {
       id: _util.OPS.moveTo,
       numArgs: 2,
       variableArgs: false
     };
-    t["l"] = {
+    t.l = {
       id: _util.OPS.lineTo,
       numArgs: 2,
       variableArgs: false
     };
-    t["c"] = {
+    t.c = {
       id: _util.OPS.curveTo,
       numArgs: 6,
       variableArgs: false
     };
-    t["v"] = {
+    t.v = {
       id: _util.OPS.curveTo2,
       numArgs: 4,
       variableArgs: false
     };
-    t["y"] = {
+    t.y = {
       id: _util.OPS.curveTo3,
       numArgs: 4,
       variableArgs: false
     };
-    t["h"] = {
+    t.h = {
       id: _util.OPS.closePath,
       numArgs: 0,
       variableArgs: false
     };
-    t["re"] = {
+    t.re = {
       id: _util.OPS.rectangle,
       numArgs: 4,
       variableArgs: false
     };
-    t["S"] = {
+    t.S = {
       id: _util.OPS.stroke,
       numArgs: 0,
       variableArgs: false
     };
-    t["s"] = {
+    t.s = {
       id: _util.OPS.closeStroke,
       numArgs: 0,
       variableArgs: false
     };
-    t["f"] = {
+    t.f = {
       id: _util.OPS.fill,
       numArgs: 0,
       variableArgs: false
     };
-    t["F"] = {
+    t.F = {
       id: _util.OPS.fill,
       numArgs: 0,
       variableArgs: false
@@ -3197,7 +3235,7 @@ var EvaluatorPreprocessor = function EvaluatorPreprocessorClosure() {
       numArgs: 0,
       variableArgs: false
     };
-    t["B"] = {
+    t.B = {
       id: _util.OPS.fillStroke,
       numArgs: 0,
       variableArgs: false
@@ -3207,7 +3245,7 @@ var EvaluatorPreprocessor = function EvaluatorPreprocessorClosure() {
       numArgs: 0,
       variableArgs: false
     };
-    t["b"] = {
+    t.b = {
       id: _util.OPS.closeFillStroke,
       numArgs: 0,
       variableArgs: false
@@ -3217,12 +3255,12 @@ var EvaluatorPreprocessor = function EvaluatorPreprocessorClosure() {
       numArgs: 0,
       variableArgs: false
     };
-    t["n"] = {
+    t.n = {
       id: _util.OPS.endPath,
       numArgs: 0,
       variableArgs: false
     };
-    t["W"] = {
+    t.W = {
       id: _util.OPS.clip,
       numArgs: 0,
       variableArgs: false
@@ -3232,62 +3270,62 @@ var EvaluatorPreprocessor = function EvaluatorPreprocessorClosure() {
       numArgs: 0,
       variableArgs: false
     };
-    t["BT"] = {
+    t.BT = {
       id: _util.OPS.beginText,
       numArgs: 0,
       variableArgs: false
     };
-    t["ET"] = {
+    t.ET = {
       id: _util.OPS.endText,
       numArgs: 0,
       variableArgs: false
     };
-    t["Tc"] = {
+    t.Tc = {
       id: _util.OPS.setCharSpacing,
       numArgs: 1,
       variableArgs: false
     };
-    t["Tw"] = {
+    t.Tw = {
       id: _util.OPS.setWordSpacing,
       numArgs: 1,
       variableArgs: false
     };
-    t["Tz"] = {
+    t.Tz = {
       id: _util.OPS.setHScale,
       numArgs: 1,
       variableArgs: false
     };
-    t["TL"] = {
+    t.TL = {
       id: _util.OPS.setLeading,
       numArgs: 1,
       variableArgs: false
     };
-    t["Tf"] = {
+    t.Tf = {
       id: _util.OPS.setFont,
       numArgs: 2,
       variableArgs: false
     };
-    t["Tr"] = {
+    t.Tr = {
       id: _util.OPS.setTextRenderingMode,
       numArgs: 1,
       variableArgs: false
     };
-    t["Ts"] = {
+    t.Ts = {
       id: _util.OPS.setTextRise,
       numArgs: 1,
       variableArgs: false
     };
-    t["Td"] = {
+    t.Td = {
       id: _util.OPS.moveText,
       numArgs: 2,
       variableArgs: false
     };
-    t["TD"] = {
+    t.TD = {
       id: _util.OPS.setLeadingMoveText,
       numArgs: 2,
       variableArgs: false
     };
-    t["Tm"] = {
+    t.Tm = {
       id: _util.OPS.setTextMatrix,
       numArgs: 6,
       variableArgs: false
@@ -3297,12 +3335,12 @@ var EvaluatorPreprocessor = function EvaluatorPreprocessorClosure() {
       numArgs: 0,
       variableArgs: false
     };
-    t["Tj"] = {
+    t.Tj = {
       id: _util.OPS.showText,
       numArgs: 1,
       variableArgs: false
     };
-    t["TJ"] = {
+    t.TJ = {
       id: _util.OPS.showSpacedText,
       numArgs: 1,
       variableArgs: false
@@ -3317,146 +3355,146 @@ var EvaluatorPreprocessor = function EvaluatorPreprocessorClosure() {
       numArgs: 3,
       variableArgs: false
     };
-    t["d0"] = {
+    t.d0 = {
       id: _util.OPS.setCharWidth,
       numArgs: 2,
       variableArgs: false
     };
-    t["d1"] = {
+    t.d1 = {
       id: _util.OPS.setCharWidthAndBounds,
       numArgs: 6,
       variableArgs: false
     };
-    t["CS"] = {
+    t.CS = {
       id: _util.OPS.setStrokeColorSpace,
       numArgs: 1,
       variableArgs: false
     };
-    t["cs"] = {
+    t.cs = {
       id: _util.OPS.setFillColorSpace,
       numArgs: 1,
       variableArgs: false
     };
-    t["SC"] = {
+    t.SC = {
       id: _util.OPS.setStrokeColor,
       numArgs: 4,
       variableArgs: true
     };
-    t["SCN"] = {
+    t.SCN = {
       id: _util.OPS.setStrokeColorN,
       numArgs: 33,
       variableArgs: true
     };
-    t["sc"] = {
+    t.sc = {
       id: _util.OPS.setFillColor,
       numArgs: 4,
       variableArgs: true
     };
-    t["scn"] = {
+    t.scn = {
       id: _util.OPS.setFillColorN,
       numArgs: 33,
       variableArgs: true
     };
-    t["G"] = {
+    t.G = {
       id: _util.OPS.setStrokeGray,
       numArgs: 1,
       variableArgs: false
     };
-    t["g"] = {
+    t.g = {
       id: _util.OPS.setFillGray,
       numArgs: 1,
       variableArgs: false
     };
-    t["RG"] = {
+    t.RG = {
       id: _util.OPS.setStrokeRGBColor,
       numArgs: 3,
       variableArgs: false
     };
-    t["rg"] = {
+    t.rg = {
       id: _util.OPS.setFillRGBColor,
       numArgs: 3,
       variableArgs: false
     };
-    t["K"] = {
+    t.K = {
       id: _util.OPS.setStrokeCMYKColor,
       numArgs: 4,
       variableArgs: false
     };
-    t["k"] = {
+    t.k = {
       id: _util.OPS.setFillCMYKColor,
       numArgs: 4,
       variableArgs: false
     };
-    t["sh"] = {
+    t.sh = {
       id: _util.OPS.shadingFill,
       numArgs: 1,
       variableArgs: false
     };
-    t["BI"] = {
+    t.BI = {
       id: _util.OPS.beginInlineImage,
       numArgs: 0,
       variableArgs: false
     };
-    t["ID"] = {
+    t.ID = {
       id: _util.OPS.beginImageData,
       numArgs: 0,
       variableArgs: false
     };
-    t["EI"] = {
+    t.EI = {
       id: _util.OPS.endInlineImage,
       numArgs: 1,
       variableArgs: false
     };
-    t["Do"] = {
+    t.Do = {
       id: _util.OPS.paintXObject,
       numArgs: 1,
       variableArgs: false
     };
-    t["MP"] = {
+    t.MP = {
       id: _util.OPS.markPoint,
       numArgs: 1,
       variableArgs: false
     };
-    t["DP"] = {
+    t.DP = {
       id: _util.OPS.markPointProps,
       numArgs: 2,
       variableArgs: false
     };
-    t["BMC"] = {
+    t.BMC = {
       id: _util.OPS.beginMarkedContent,
       numArgs: 1,
       variableArgs: false
     };
-    t["BDC"] = {
+    t.BDC = {
       id: _util.OPS.beginMarkedContentProps,
       numArgs: 2,
       variableArgs: false
     };
-    t["EMC"] = {
+    t.EMC = {
       id: _util.OPS.endMarkedContent,
       numArgs: 0,
       variableArgs: false
     };
-    t["BX"] = {
+    t.BX = {
       id: _util.OPS.beginCompat,
       numArgs: 0,
       variableArgs: false
     };
-    t["EX"] = {
+    t.EX = {
       id: _util.OPS.endCompat,
       numArgs: 0,
       variableArgs: false
     };
-    t["BM"] = null;
-    t["BD"] = null;
-    t["true"] = null;
-    t["fa"] = null;
-    t["fal"] = null;
-    t["fals"] = null;
-    t["false"] = null;
-    t["nu"] = null;
-    t["nul"] = null;
-    t["null"] = null;
+    t.BM = null;
+    t.BD = null;
+    t.true = null;
+    t.fa = null;
+    t.fal = null;
+    t.fals = null;
+    t.false = null;
+    t.nu = null;
+    t.nul = null;
+    t.null = null;
   });
   const MAX_INVALID_PATH_OPS = 20;