pdfjs-dist 2.0.943 → 2.4.456

package/lib/core/evaluator.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2018 Mozilla Foundation
+ * Copyright 2020 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,61 +19,57 @@
  * @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.PartialEvaluator = undefined;
+exports.PartialEvaluator = void 0;
 
-var _regenerator = require('babel-runtime/regenerator');
+var _util = require("../shared/util.js");
 
-var _regenerator2 = _interopRequireDefault(_regenerator);
+var _cmap = require("./cmap.js");
 
-var _util = require('../shared/util');
+var _primitives = require("./primitives.js");
 
-var _cmap = require('./cmap');
+var _fonts = require("./fonts.js");
 
-var _stream = require('./stream');
+var _encodings = require("./encodings.js");
 
-var _primitives = require('./primitives');
+var _core_utils = require("./core_utils.js");
 
-var _fonts = require('./fonts');
+var _unicode = require("./unicode.js");
 
-var _encodings = require('./encodings');
+var _standard_fonts = require("./standard_fonts.js");
 
-var _unicode = require('./unicode');
+var _pattern = require("./pattern.js");
 
-var _standard_fonts = require('./standard_fonts');
+var _parser = require("./parser.js");
 
-var _pattern = require('./pattern');
+var _bidi = require("./bidi.js");
 
-var _parser = require('./parser');
+var _colorspace = require("./colorspace.js");
 
-var _bidi = require('./bidi');
+var _stream = require("./stream.js");
 
-var _colorspace = require('./colorspace');
+var _glyphlist = require("./glyphlist.js");
 
-var _glyphlist = require('./glyphlist');
+var _metrics = require("./metrics.js");
 
-var _metrics = require('./metrics');
+var _function = require("./function.js");
 
-var _function = require('./function');
+var _jpeg_stream = require("./jpeg_stream.js");
 
-var _jpeg_stream = require('./jpeg_stream');
+var _murmurhash = require("./murmurhash3.js");
 
-var _murmurhash = require('./murmurhash3');
+var _image_utils = require("./image_utils.js");
 
-var _operator_list = require('./operator_list');
+var _operator_list = require("./operator_list.js");
 
-var _image = require('./image');
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function _asyncToGenerator(fn) { return function () { var gen = fn.apply(this, arguments); return new Promise(function (resolve, reject) { function step(key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { return Promise.resolve(value).then(function (value) { step("next", value); }, function (err) { step("throw", err); }); } } return step("next"); }); }; }
+var _image = require("./image.js");
 
 var PartialEvaluator = function PartialEvaluatorClosure() {
-  var DefaultPartialEvaluatorOptions = {
+  const DefaultPartialEvaluatorOptions = {
     forceDataSchema: false,
     maxImageSize: -1,
     disableFontFace: false,
@@ -81,68 +77,17 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
     ignoreErrors: false,
     isEvalSupported: true
   };
-  function NativeImageDecoder(_ref) {
-    var xref = _ref.xref,
-        resources = _ref.resources,
-        handler = _ref.handler,
-        _ref$forceDataSchema = _ref.forceDataSchema,
-        forceDataSchema = _ref$forceDataSchema === undefined ? false : _ref$forceDataSchema,
-        pdfFunctionFactory = _ref.pdfFunctionFactory;
 
-    this.xref = xref;
-    this.resources = resources;
-    this.handler = handler;
-    this.forceDataSchema = forceDataSchema;
-    this.pdfFunctionFactory = pdfFunctionFactory;
-  }
-  NativeImageDecoder.prototype = {
-    canDecode: function canDecode(image) {
-      return image instanceof _jpeg_stream.JpegStream && NativeImageDecoder.isDecodable(image, this.xref, this.resources, this.pdfFunctionFactory);
-    },
-    decode: function decode(image) {
-      var dict = image.dict;
-      var 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 (_ref2) {
-        var data = _ref2.data,
-            width = _ref2.width,
-            height = _ref2.height;
-
-        return new _stream.Stream(data, 0, data.length, image.dict);
-      });
-    }
-  };
-  NativeImageDecoder.isSupported = function (image, xref, res, pdfFunctionFactory) {
-    var dict = image.dict;
-    if (dict.has('DecodeParms') || dict.has('DP')) {
-      return false;
-    }
-    var cs = _colorspace.ColorSpace.parse(dict.get('ColorSpace', 'CS'), xref, res, pdfFunctionFactory);
-    return (cs.name === 'DeviceGray' || cs.name === 'DeviceRGB') && cs.isDefaultDecode(dict.getArray('Decode', 'D'));
-  };
-  NativeImageDecoder.isDecodable = function (image, xref, res, pdfFunctionFactory) {
-    var dict = image.dict;
-    if (dict.has('DecodeParms') || dict.has('DP')) {
-      return false;
-    }
-    var cs = _colorspace.ColorSpace.parse(dict.get('ColorSpace', 'CS'), xref, res, pdfFunctionFactory);
-    return (cs.numComps === 1 || cs.numComps === 3) && cs.isDefaultDecode(dict.getArray('Decode', 'D'));
-  };
-  function PartialEvaluator(_ref3) {
-    var _this = this;
-
-    var pdfManager = _ref3.pdfManager,
-        xref = _ref3.xref,
-        handler = _ref3.handler,
-        pageIndex = _ref3.pageIndex,
-        idFactory = _ref3.idFactory,
-        fontCache = _ref3.fontCache,
-        builtInCMapCache = _ref3.builtInCMapCache,
-        _ref3$options = _ref3.options,
-        options = _ref3$options === undefined ? null : _ref3$options,
-        pdfFunctionFactory = _ref3.pdfFunctionFactory;
-
-    this.pdfManager = pdfManager;
+  function PartialEvaluator({
+    xref,
+    handler,
+    pageIndex,
+    idFactory,
+    fontCache,
+    builtInCMapCache,
+    options = null,
+    pdfFunctionFactory
+  }) {
     this.xref = xref;
     this.handler = handler;
     this.pageIndex = pageIndex;
@@ -151,55 +96,56 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
     this.builtInCMapCache = builtInCMapCache;
     this.options = options || DefaultPartialEvaluatorOptions;
     this.pdfFunctionFactory = pdfFunctionFactory;
-    this.fetchBuiltInCMap = function () {
-      var _ref4 = _asyncToGenerator( /*#__PURE__*/_regenerator2.default.mark(function _callee(name) {
-        var data;
-        return _regenerator2.default.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                if (!_this.builtInCMapCache.has(name)) {
-                  _context.next = 2;
-                  break;
-                }
+    this.parsingType3Font = false;
 
-                return _context.abrupt('return', _this.builtInCMapCache.get(name));
+    this.fetchBuiltInCMap = async name => {
+      if (this.builtInCMapCache.has(name)) {
+        return this.builtInCMapCache.get(name);
+      }
 
-              case 2:
-                _context.next = 4;
-                return _this.handler.sendWithPromise('FetchBuiltInCMap', { name: name });
+      const readableStream = this.handler.sendWithStream("FetchBuiltInCMap", {
+        name
+      });
+      const reader = readableStream.getReader();
+      const data = await new Promise(function (resolve, reject) {
+        function pump() {
+          reader.read().then(function ({
+            value,
+            done
+          }) {
+            if (done) {
+              return;
+            }
 
-              case 4:
-                data = _context.sent;
+            resolve(value);
+            pump();
+          }, reject);
+        }
 
-                if (data.compressionType !== _util.CMapCompressionType.NONE) {
-                  _this.builtInCMapCache.set(name, data);
-                }
-                return _context.abrupt('return', data);
+        pump();
+      });
 
-              case 7:
-              case 'end':
-                return _context.stop();
-            }
-          }
-        }, _callee, _this);
-      }));
+      if (data.compressionType !== _util.CMapCompressionType.NONE) {
+        this.builtInCMapCache.set(name, data);
+      }
 
-      return function (_x) {
-        return _ref4.apply(this, arguments);
-      };
-    }();
+      return data;
+    };
   }
+
   var TIME_SLOT_DURATION_MS = 20;
   var CHECK_TIME_EVERY = 100;
+
   function TimeSlotManager() {
     this.reset();
   }
+
   TimeSlotManager.prototype = {
     check: function TimeSlotManager_check() {
       if (++this.checked < CHECK_TIME_EVERY) {
         return false;
       }
+
       this.checked = 0;
       return this.endTime <= Date.now();
     },
@@ -208,319 +154,505 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
       this.checked = 0;
     }
   };
-  function normalizeBlendMode(value) {
+
+  function normalizeBlendMode(value, parsingArray = false) {
+    if (Array.isArray(value)) {
+      for (let i = 0, ii = value.length; i < ii; i++) {
+        const maybeBM = normalizeBlendMode(value[i], true);
+
+        if (maybeBM) {
+          return maybeBM;
+        }
+      }
+
+      (0, _util.warn)(`Unsupported blend mode Array: ${value}`);
+      return "source-over";
+    }
+
     if (!(0, _primitives.isName)(value)) {
-      return 'source-over';
+      if (parsingArray) {
+        return null;
+      }
+
+      return "source-over";
     }
+
     switch (value.name) {
-      case 'Normal':
-      case 'Compatible':
-        return 'source-over';
-      case 'Multiply':
-        return 'multiply';
-      case 'Screen':
-        return 'screen';
-      case 'Overlay':
-        return 'overlay';
-      case 'Darken':
-        return 'darken';
-      case 'Lighten':
-        return 'lighten';
-      case 'ColorDodge':
-        return 'color-dodge';
-      case 'ColorBurn':
-        return 'color-burn';
-      case 'HardLight':
-        return 'hard-light';
-      case 'SoftLight':
-        return 'soft-light';
-      case 'Difference':
-        return 'difference';
-      case 'Exclusion':
-        return 'exclusion';
-      case 'Hue':
-        return 'hue';
-      case 'Saturation':
-        return 'saturation';
-      case 'Color':
-        return 'color';
-      case 'Luminosity':
-        return 'luminosity';
+      case "Normal":
+      case "Compatible":
+        return "source-over";
+
+      case "Multiply":
+        return "multiply";
+
+      case "Screen":
+        return "screen";
+
+      case "Overlay":
+        return "overlay";
+
+      case "Darken":
+        return "darken";
+
+      case "Lighten":
+        return "lighten";
+
+      case "ColorDodge":
+        return "color-dodge";
+
+      case "ColorBurn":
+        return "color-burn";
+
+      case "HardLight":
+        return "hard-light";
+
+      case "SoftLight":
+        return "soft-light";
+
+      case "Difference":
+        return "difference";
+
+      case "Exclusion":
+        return "exclusion";
+
+      case "Hue":
+        return "hue";
+
+      case "Saturation":
+        return "saturation";
+
+      case "Color":
+        return "color";
+
+      case "Luminosity":
+        return "luminosity";
+    }
+
+    if (parsingArray) {
+      return null;
     }
-    (0, _util.warn)('Unsupported blend mode: ' + value.name);
-    return 'source-over';
+
+    (0, _util.warn)(`Unsupported blend mode: ${value.name}`);
+    return "source-over";
   }
+
   var deferred = Promise.resolve();
   var TILING_PATTERN = 1,
       SHADING_PATTERN = 2;
   PartialEvaluator.prototype = {
-    clone: function clone() {
-      var newOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DefaultPartialEvaluatorOptions;
-
+    clone(newOptions = DefaultPartialEvaluatorOptions) {
       var newEvaluator = Object.create(this);
       newEvaluator.options = newOptions;
       return newEvaluator;
     },
 
     hasBlendModes: function PartialEvaluator_hasBlendModes(resources) {
-      if (!(0, _primitives.isDict)(resources)) {
+      if (!(resources instanceof _primitives.Dict)) {
         return false;
       }
+
       var processed = Object.create(null);
+
       if (resources.objId) {
         processed[resources.objId] = true;
       }
+
       var nodes = [resources],
           xref = this.xref;
+
       while (nodes.length) {
-        var key, i, ii;
         var node = nodes.shift();
-        var graphicStates = node.get('ExtGState');
-        if ((0, _primitives.isDict)(graphicStates)) {
+        var graphicStates = node.get("ExtGState");
+
+        if (graphicStates instanceof _primitives.Dict) {
           var graphicStatesKeys = graphicStates.getKeys();
-          for (i = 0, ii = graphicStatesKeys.length; i < ii; i++) {
-            key = graphicStatesKeys[i];
-            var graphicState = graphicStates.get(key);
-            var bm = graphicState.get('BM');
-            if ((0, _primitives.isName)(bm) && bm.name !== 'Normal') {
-              return true;
+
+          for (let i = 0, ii = graphicStatesKeys.length; i < ii; i++) {
+            const key = graphicStatesKeys[i];
+            let graphicState = graphicStates.getRaw(key);
+
+            if (graphicState instanceof _primitives.Ref) {
+              if (processed[graphicState.toString()]) {
+                continue;
+              }
+
+              try {
+                graphicState = xref.fetch(graphicState);
+              } catch (ex) {
+                if (ex instanceof _core_utils.MissingDataException) {
+                  throw ex;
+                }
+
+                if (this.options.ignoreErrors) {
+                  if (graphicState instanceof _primitives.Ref) {
+                    processed[graphicState.toString()] = true;
+                  }
+
+                  this.handler.send("UnsupportedFeature", {
+                    featureId: _util.UNSUPPORTED_FEATURES.unknown
+                  });
+                  (0, _util.warn)(`hasBlendModes - ignoring ExtGState: "${ex}".`);
+                  continue;
+                }
+
+                throw ex;
+              }
+            }
+
+            if (!(graphicState instanceof _primitives.Dict)) {
+              continue;
+            }
+
+            if (graphicState.objId) {
+              processed[graphicState.objId] = true;
+            }
+
+            const bm = graphicState.get("BM");
+
+            if (bm instanceof _primitives.Name) {
+              if (bm.name !== "Normal") {
+                return true;
+              }
+
+              continue;
+            }
+
+            if (bm !== undefined && Array.isArray(bm)) {
+              for (let j = 0, jj = bm.length; j < jj; j++) {
+                if (bm[j] instanceof _primitives.Name && bm[j].name !== "Normal") {
+                  return true;
+                }
+              }
             }
           }
         }
-        var xObjects = node.get('XObject');
-        if (!(0, _primitives.isDict)(xObjects)) {
+
+        var xObjects = node.get("XObject");
+
+        if (!(xObjects instanceof _primitives.Dict)) {
           continue;
         }
+
         var xObjectsKeys = xObjects.getKeys();
-        for (i = 0, ii = xObjectsKeys.length; i < ii; i++) {
-          key = xObjectsKeys[i];
+
+        for (let i = 0, ii = xObjectsKeys.length; i < ii; i++) {
+          const key = xObjectsKeys[i];
           var xObject = xObjects.getRaw(key);
-          if ((0, _primitives.isRef)(xObject)) {
+
+          if (xObject instanceof _primitives.Ref) {
             if (processed[xObject.toString()]) {
               continue;
             }
-            xObject = xref.fetch(xObject);
+
+            try {
+              xObject = xref.fetch(xObject);
+            } catch (ex) {
+              if (ex instanceof _core_utils.MissingDataException) {
+                throw ex;
+              }
+
+              if (this.options.ignoreErrors) {
+                if (xObject instanceof _primitives.Ref) {
+                  processed[xObject.toString()] = true;
+                }
+
+                this.handler.send("UnsupportedFeature", {
+                  featureId: _util.UNSUPPORTED_FEATURES.unknown
+                });
+                (0, _util.warn)(`hasBlendModes - ignoring XObject: "${ex}".`);
+                continue;
+              }
+
+              throw ex;
+            }
           }
+
           if (!(0, _primitives.isStream)(xObject)) {
             continue;
           }
+
           if (xObject.dict.objId) {
             if (processed[xObject.dict.objId]) {
               continue;
             }
+
             processed[xObject.dict.objId] = true;
           }
-          var xResources = xObject.dict.get('Resources');
-          if ((0, _primitives.isDict)(xResources) && (!xResources.objId || !processed[xResources.objId])) {
+
+          var xResources = xObject.dict.get("Resources");
+
+          if (xResources instanceof _primitives.Dict && (!xResources.objId || !processed[xResources.objId])) {
             nodes.push(xResources);
+
             if (xResources.objId) {
               processed[xResources.objId] = true;
             }
           }
         }
       }
+
       return false;
     },
-    buildFormXObject: function PartialEvaluator_buildFormXObject(resources, xobj, smask, operatorList, task, initialState) {
+
+    async buildFormXObject(resources, xobj, smask, operatorList, task, initialState) {
       var dict = xobj.dict;
-      var matrix = dict.getArray('Matrix');
-      var bbox = dict.getArray('BBox');
-      var group = dict.get('Group');
+      var matrix = dict.getArray("Matrix");
+      var bbox = dict.getArray("BBox");
+
+      if (Array.isArray(bbox) && bbox.length === 4) {
+        bbox = _util.Util.normalizeRect(bbox);
+      } else {
+        bbox = null;
+      }
+
+      var group = dict.get("Group");
+
       if (group) {
         var groupOptions = {
-          matrix: matrix,
-          bbox: bbox,
-          smask: smask,
+          matrix,
+          bbox,
+          smask,
           isolated: false,
           knockout: false
         };
-        var groupSubtype = group.get('S');
+        var groupSubtype = group.get("S");
         var colorSpace = null;
-        if ((0, _primitives.isName)(groupSubtype, 'Transparency')) {
-          groupOptions.isolated = group.get('I') || false;
-          groupOptions.knockout = group.get('K') || false;
-          if (group.has('CS')) {
-            colorSpace = _colorspace.ColorSpace.parse(group.get('CS'), this.xref, resources, this.pdfFunctionFactory);
+
+        if ((0, _primitives.isName)(groupSubtype, "Transparency")) {
+          groupOptions.isolated = group.get("I") || false;
+          groupOptions.knockout = group.get("K") || false;
+
+          if (group.has("CS")) {
+            colorSpace = await this.parseColorSpace({
+              cs: group.get("CS"),
+              resources
+            });
           }
         }
+
         if (smask && smask.backdrop) {
           colorSpace = colorSpace || _colorspace.ColorSpace.singletons.rgb;
           smask.backdrop = colorSpace.getRgb(smask.backdrop, 0);
         }
+
         operatorList.addOp(_util.OPS.beginGroup, [groupOptions]);
       }
+
       operatorList.addOp(_util.OPS.paintFormXObjectBegin, [matrix, bbox]);
       return this.getOperatorList({
         stream: xobj,
-        task: task,
-        resources: dict.get('Resources') || resources,
-        operatorList: operatorList,
-        initialState: initialState
+        task,
+        resources: dict.get("Resources") || resources,
+        operatorList,
+        initialState
       }).then(function () {
         operatorList.addOp(_util.OPS.paintFormXObjectEnd, []);
+
         if (group) {
           operatorList.addOp(_util.OPS.endGroup, [groupOptions]);
         }
       });
     },
-    buildPaintImageXObject: function buildPaintImageXObject(_ref5) {
-      var _this2 = this;
-
-      var resources = _ref5.resources,
-          image = _ref5.image,
-          _ref5$isInline = _ref5.isInline,
-          isInline = _ref5$isInline === undefined ? false : _ref5$isInline,
-          operatorList = _ref5.operatorList,
-          cacheKey = _ref5.cacheKey,
-          imageCache = _ref5.imageCache,
-          _ref5$forceDisableNat = _ref5.forceDisableNativeImageDecoder,
-          forceDisableNativeImageDecoder = _ref5$forceDisableNat === undefined ? false : _ref5$forceDisableNat;
 
+    async buildPaintImageXObject({
+      resources,
+      image,
+      isInline = false,
+      operatorList,
+      cacheKey,
+      imageCache,
+      forceDisableNativeImageDecoder = false
+    }) {
       var dict = image.dict;
-      var w = dict.get('Width', 'W');
-      var h = dict.get('Height', 'H');
+      var w = dict.get("Width", "W");
+      var h = dict.get("Height", "H");
+
       if (!(w && (0, _util.isNum)(w)) || !(h && (0, _util.isNum)(h))) {
-        (0, _util.warn)('Image dimensions are missing, or not numbers.');
-        return Promise.resolve();
+        (0, _util.warn)("Image dimensions are missing, or not numbers.");
+        return undefined;
       }
+
       var maxImageSize = this.options.maxImageSize;
+
       if (maxImageSize !== -1 && w * h > maxImageSize) {
-        (0, _util.warn)('Image exceeded maximum allowed size and was removed.');
-        return Promise.resolve();
+        (0, _util.warn)("Image exceeded maximum allowed size and was removed.");
+        return undefined;
       }
-      var imageMask = dict.get('ImageMask', 'IM') || false;
+
+      var imageMask = dict.get("ImageMask", "IM") || false;
       var imgData, args;
+
       if (imageMask) {
-        var width = dict.get('Width', 'W');
-        var height = dict.get('Height', 'H');
+        var width = dict.get("Width", "W");
+        var height = dict.get("Height", "H");
         var bitStrideLength = width + 7 >> 3;
         var imgArray = image.getBytes(bitStrideLength * height, true);
-        var decode = dict.getArray('Decode', 'D');
+        var decode = dict.getArray("Decode", "D");
         imgData = _image.PDFImage.createMask({
-          imgArray: imgArray,
-          width: width,
-          height: height,
+          imgArray,
+          width,
+          height,
           imageIsFromDecodeStream: image instanceof _stream.DecodeStream,
           inverseDecode: !!decode && decode[0] > 0
         });
-        imgData.cached = true;
+        imgData.cached = !!cacheKey;
         args = [imgData];
         operatorList.addOp(_util.OPS.paintImageMaskXObject, args);
+
         if (cacheKey) {
           imageCache[cacheKey] = {
             fn: _util.OPS.paintImageMaskXObject,
-            args: args
+            args
           };
         }
-        return Promise.resolve();
+
+        return undefined;
       }
-      var softMask = dict.get('SMask', 'SM') || false;
-      var mask = dict.get('Mask') || false;
+
+      var softMask = dict.get("SMask", "SM") || false;
+      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) {
-        var imageObj = new _image.PDFImage({
+        const imageObj = new _image.PDFImage({
           xref: this.xref,
           res: resources,
-          image: image,
-          isInline: isInline,
+          image,
+          isInline,
           pdfFunctionFactory: this.pdfFunctionFactory
         });
         imgData = imageObj.createImageData(true);
         operatorList.addOp(_util.OPS.paintInlineImageXObject, [imgData]);
-        return Promise.resolve();
+        return undefined;
+      }
+
+      const nativeImageDecoderSupport = forceDisableNativeImageDecoder ? _util.NativeImageDecoding.NONE : this.options.nativeImageDecoderSupport;
+      let objId = `img_${this.idFactory.createObjId()}`;
+
+      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}`;
       }
-      var nativeImageDecoderSupport = forceDisableNativeImageDecoder ? _util.NativeImageDecoding.NONE : this.options.nativeImageDecoderSupport;
-      var objId = 'img_' + this.idFactory.createObjId();
-      if (nativeImageDecoderSupport !== _util.NativeImageDecoding.NONE && !softMask && !mask && image instanceof _jpeg_stream.JpegStream && NativeImageDecoder.isSupported(image, this.xref, resources, this.pdfFunctionFactory)) {
-        return this.handler.sendWithPromise('obj', [objId, this.pageIndex, 'JpegStream', image.getIR(this.options.forceDataSchema)]).then(function () {
+
+      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: args
+              args
             };
           }
-        }, function (reason) {
-          (0, _util.warn)('Native JPEG decoding failed -- trying to recover: ' + (reason && reason.message));
-          return _this2.buildPaintImageXObject({
-            resources: resources,
-            image: image,
-            isInline: isInline,
-            operatorList: operatorList,
-            cacheKey: cacheKey,
-            imageCache: imageCache,
+        }, 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;
+
       if (nativeImageDecoderSupport === _util.NativeImageDecoding.DECODE && (image instanceof _jpeg_stream.JpegStream || mask instanceof _jpeg_stream.JpegStream || softMask instanceof _jpeg_stream.JpegStream)) {
-        nativeImageDecoder = new NativeImageDecoder({
+        nativeImageDecoder = new _image_utils.NativeImageDecoder({
           xref: this.xref,
-          resources: resources,
+          resources,
           handler: this.handler,
           forceDataSchema: this.options.forceDataSchema,
           pdfFunctionFactory: this.pdfFunctionFactory
         });
       }
+
       operatorList.addDependency(objId);
       args = [objId, w, h];
-      _image.PDFImage.buildImage({
+
+      const imgPromise = _image.PDFImage.buildImage({
         handler: this.handler,
         xref: this.xref,
         res: resources,
-        image: image,
-        isInline: isInline,
+        image,
+        isInline,
         nativeDecoder: nativeImageDecoder,
         pdfFunctionFactory: this.pdfFunctionFactory
-      }).then(function (imageObj) {
+      }).then(imageObj => {
         var imgData = imageObj.createImageData(false);
-        _this2.handler.send('obj', [objId, _this2.pageIndex, 'Image', imgData], [imgData.data.buffer]);
-      }).catch(function (reason) {
-        (0, _util.warn)('Unable to decode image: ' + reason);
-        _this2.handler.send('obj', [objId, _this2.pageIndex, 'Image', null]);
+
+        if (this.parsingType3Font) {
+          return this.handler.sendWithPromise("commonobj", [objId, "FontType3Res", imgData], [imgData.data.buffer]);
+        }
+
+        this.handler.send("obj", [objId, this.pageIndex, "Image", imgData], [imgData.data.buffer]);
+        return undefined;
+      }).catch(reason => {
+        (0, _util.warn)("Unable to decode image: " + reason);
+
+        if (this.parsingType3Font) {
+          return this.handler.sendWithPromise("commonobj", [objId, "FontType3Res", null]);
+        }
+
+        this.handler.send("obj", [objId, this.pageIndex, "Image", null]);
+        return undefined;
       });
+
+      if (this.parsingType3Font) {
+        await imgPromise;
+      }
+
       operatorList.addOp(_util.OPS.paintImageXObject, args);
+
       if (cacheKey) {
         imageCache[cacheKey] = {
           fn: _util.OPS.paintImageXObject,
-          args: args
+          args
         };
       }
-      return Promise.resolve();
+
+      return undefined;
     },
 
     handleSMask: function PartialEvaluator_handleSmask(smask, resources, operatorList, task, stateManager) {
-      var smaskContent = smask.get('G');
+      var smaskContent = smask.get("G");
       var smaskOptions = {
-        subtype: smask.get('S').name,
-        backdrop: smask.get('BC')
+        subtype: smask.get("S").name,
+        backdrop: smask.get("BC")
       };
-      var transferObj = smask.get('TR');
+      var transferObj = smask.get("TR");
+
       if ((0, _function.isPDFFunction)(transferObj)) {
-        var transferFn = this.pdfFunctionFactory.create(transferObj);
+        const transferFn = this.pdfFunctionFactory.create(transferObj);
         var transferMap = new Uint8Array(256);
         var tmp = new Float32Array(1);
+
         for (var i = 0; i < 256; i++) {
           tmp[0] = i / 255;
           transferFn(tmp, 0, tmp, 0);
           transferMap[i] = tmp[0] * 255 | 0;
         }
+
         smaskOptions.transferMap = transferMap;
       }
+
       return this.buildFormXObject(resources, smaskContent, smaskOptions, operatorList, task, stateManager.state.clone());
     },
-    handleTilingType: function handleTilingType(fn, args, resources, pattern, patternDict, operatorList, task) {
-      var _this3 = this;
 
-      var tilingOpList = new _operator_list.OperatorList();
-      var resourcesArray = [patternDict.get('Resources'), resources];
-      var patternResources = _primitives.Dict.merge(this.xref, resourcesArray);
+    handleTilingType(fn, args, resources, pattern, patternDict, operatorList, task) {
+      const tilingOpList = new _operator_list.OperatorList();
+      const resourcesArray = [patternDict.get("Resources"), resources];
+
+      const patternResources = _primitives.Dict.merge(this.xref, resourcesArray);
+
       return this.getOperatorList({
         stream: pattern,
-        task: task,
+        task,
         resources: patternResources,
         operatorList: tilingOpList
       }).then(function () {
@@ -531,138 +663,162 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
       }).then(function (tilingPatternIR) {
         operatorList.addDependencies(tilingOpList.dependencies);
         operatorList.addOp(fn, tilingPatternIR);
-      }, function (reason) {
-        if (_this3.options.ignoreErrors) {
-          _this3.handler.send('UnsupportedFeature', { featureId: _util.UNSUPPORTED_FEATURES.unknown });
-          (0, _util.warn)('handleTilingType - ignoring pattern: "' + reason + '".');
+      }, reason => {
+        if (reason instanceof _util.AbortException) {
           return;
         }
+
+        if (this.options.ignoreErrors) {
+          this.handler.send("UnsupportedFeature", {
+            featureId: _util.UNSUPPORTED_FEATURES.unknown
+          });
+          (0, _util.warn)(`handleTilingType - ignoring pattern: "${reason}".`);
+          return;
+        }
+
         throw reason;
       });
     },
 
     handleSetFont: function PartialEvaluator_handleSetFont(resources, fontArgs, fontRef, operatorList, task, state) {
-      var _this4 = this;
-
       var fontName;
+
       if (fontArgs) {
         fontArgs = fontArgs.slice();
         fontName = fontArgs[0].name;
       }
-      return this.loadFont(fontName, fontRef, resources).then(function (translated) {
+
+      return this.loadFont(fontName, fontRef, resources).then(translated => {
         if (!translated.font.isType3Font) {
           return translated;
         }
-        return translated.loadType3Data(_this4, resources, operatorList, task).then(function () {
+
+        return translated.loadType3Data(this, resources, operatorList, task).then(function () {
           return translated;
-        }).catch(function (reason) {
-          _this4.handler.send('UnsupportedFeature', { featureId: _util.UNSUPPORTED_FEATURES.font });
-          return new TranslatedFont('g_font_error', new _fonts.ErrorFont('Type3 font load error: ' + reason), translated.font);
+        }).catch(reason => {
+          this.handler.send("UnsupportedFeature", {
+            featureId: _util.UNSUPPORTED_FEATURES.font
+          });
+          return new TranslatedFont("g_font_error", new _fonts.ErrorFont("Type3 font load error: " + reason), translated.font);
         });
-      }).then(function (translated) {
+      }).then(translated => {
         state.font = translated.font;
-        translated.send(_this4.handler);
+        translated.send(this.handler);
         return translated.loadedName;
       });
     },
-    handleText: function PartialEvaluator_handleText(chars, state) {
-      var _this5 = this;
-
-      var font = state.font;
-      var glyphs = font.charsToGlyphs(chars);
-      var isAddToPathSet = !!(state.textRenderingMode & _util.TextRenderingMode.ADD_TO_PATH_FLAG);
-      if (font.data && (isAddToPathSet || this.options.disableFontFace || state.fillColorSpace.name === 'Pattern')) {
-        var buildPath = function buildPath(fontChar) {
-          if (!font.renderer.hasBuiltPath(fontChar)) {
-            var path = font.renderer.getPathJs(fontChar);
-            _this5.handler.send('commonobj', [font.loadedName + '_path_' + fontChar, 'FontPath', path]);
-          }
-        };
-        for (var i = 0, ii = glyphs.length; i < ii; i++) {
-          var glyph = glyphs[i];
-          buildPath(glyph.fontChar);
-          var accent = glyph.accent;
-          if (accent && accent.fontChar) {
-            buildPath(accent.fontChar);
-          }
+
+    handleText(chars, state) {
+      const font = state.font;
+      const glyphs = font.charsToGlyphs(chars);
+
+      if (font.data) {
+        const isAddToPathSet = !!(state.textRenderingMode & _util.TextRenderingMode.ADD_TO_PATH_FLAG);
+
+        if (isAddToPathSet || state.fillColorSpace.name === "Pattern" || font.disableFontFace || this.options.disableFontFace) {
+          PartialEvaluator.buildFontPaths(font, glyphs, this.handler);
         }
       }
+
       return glyphs;
     },
-    setGState: function PartialEvaluator_setGState(resources, gState, operatorList, task, stateManager) {
-      var _this6 = this;
 
+    ensureStateFont(state) {
+      if (state.font) {
+        return;
+      }
+
+      const reason = new _util.FormatError("Missing setFont (Tf) operator before text rendering operator.");
+
+      if (this.options.ignoreErrors) {
+        this.handler.send("UnsupportedFeature", {
+          featureId: _util.UNSUPPORTED_FEATURES.font
+        });
+        (0, _util.warn)(`ensureStateFont: "${reason}".`);
+        return;
+      }
+
+      throw reason;
+    },
+
+    setGState: function PartialEvaluator_setGState(resources, gState, operatorList, task, stateManager) {
       var gStateObj = [];
       var gStateKeys = gState.getKeys();
       var promise = Promise.resolve();
 
-      var _loop = function _loop() {
-        var key = gStateKeys[i];
-        var value = gState.get(key);
+      for (var i = 0, ii = gStateKeys.length; i < ii; i++) {
+        const key = gStateKeys[i];
+        const value = gState.get(key);
+
         switch (key) {
-          case 'Type':
+          case "Type":
             break;
-          case 'LW':
-          case 'LC':
-          case 'LJ':
-          case 'ML':
-          case 'D':
-          case 'RI':
-          case 'FL':
-          case 'CA':
-          case 'ca':
+
+          case "LW":
+          case "LC":
+          case "LJ":
+          case "ML":
+          case "D":
+          case "RI":
+          case "FL":
+          case "CA":
+          case "ca":
             gStateObj.push([key, value]);
             break;
-          case 'Font':
-            promise = promise.then(function () {
-              return _this6.handleSetFont(resources, null, value[0], operatorList, task, stateManager.state).then(function (loadedName) {
+
+          case "Font":
+            promise = promise.then(() => {
+              return this.handleSetFont(resources, null, value[0], operatorList, task, stateManager.state).then(function (loadedName) {
                 operatorList.addDependency(loadedName);
                 gStateObj.push([key, [loadedName, value[1]]]);
               });
             });
             break;
-          case 'BM':
+
+          case "BM":
             gStateObj.push([key, normalizeBlendMode(value)]);
             break;
-          case 'SMask':
-            if ((0, _primitives.isName)(value, 'None')) {
+
+          case "SMask":
+            if ((0, _primitives.isName)(value, "None")) {
               gStateObj.push([key, false]);
               break;
             }
+
             if ((0, _primitives.isDict)(value)) {
-              promise = promise.then(function () {
-                return _this6.handleSMask(value, resources, operatorList, task, stateManager);
+              promise = promise.then(() => {
+                return this.handleSMask(value, resources, operatorList, task, stateManager);
               });
               gStateObj.push([key, true]);
             } else {
-              (0, _util.warn)('Unsupported SMask type');
+              (0, _util.warn)("Unsupported SMask type");
             }
+
             break;
-          case 'OP':
-          case 'op':
-          case 'OPM':
-          case 'BG':
-          case 'BG2':
-          case 'UCR':
-          case 'UCR2':
-          case 'TR':
-          case 'TR2':
-          case 'HT':
-          case 'SM':
-          case 'SA':
-          case 'AIS':
-          case 'TK':
-            (0, _util.info)('graphic state operator ' + key);
+
+          case "OP":
+          case "op":
+          case "OPM":
+          case "BG":
+          case "BG2":
+          case "UCR":
+          case "UCR2":
+          case "TR":
+          case "TR2":
+          case "HT":
+          case "SM":
+          case "SA":
+          case "AIS":
+          case "TK":
+            (0, _util.info)("graphic state operator " + key);
             break;
+
           default:
-            (0, _util.info)('Unknown graphic state operator ' + key);
+            (0, _util.info)("Unknown graphic state operator " + key);
             break;
         }
-      };
-
-      for (var i = 0, ii = gStateKeys.length; i < ii; i++) {
-        _loop();
       }
+
       return promise.then(function () {
         if (gStateObj.length > 0) {
           operatorList.addOp(_util.OPS.setGState, [gStateObj]);
@@ -670,171 +826,251 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
       });
     },
     loadFont: function PartialEvaluator_loadFont(fontName, font, resources) {
-      var _this7 = this;
-
       function errorFont() {
-        return Promise.resolve(new TranslatedFont('g_font_error', new _fonts.ErrorFont('Font ' + fontName + ' is not available'), font));
+        return Promise.resolve(new TranslatedFont("g_font_error", new _fonts.ErrorFont("Font " + fontName + " is not available"), font));
       }
+
       var fontRef,
           xref = this.xref;
+
       if (font) {
         if (!(0, _primitives.isRef)(font)) {
-          throw new Error('The "font" object should be a reference.');
+          throw new _util.FormatError('The "font" object should be a reference.');
         }
+
         fontRef = font;
       } else {
-        var fontRes = resources.get('Font');
+        var fontRes = resources.get("Font");
+
         if (fontRes) {
           fontRef = fontRes.getRaw(fontName);
-        } else {
-          (0, _util.warn)('fontRes not available');
-          return errorFont();
         }
       }
+
       if (!fontRef) {
-        (0, _util.warn)('fontRef not available');
-        return errorFont();
+        const partialMsg = `Font "${fontName || font && font.toString()}" is not available`;
+
+        if (!this.options.ignoreErrors && !this.parsingType3Font) {
+          (0, _util.warn)(`${partialMsg}.`);
+          return errorFont();
+        }
+
+        this.handler.send("UnsupportedFeature", {
+          featureId: _util.UNSUPPORTED_FEATURES.font
+        });
+        (0, _util.warn)(`${partialMsg} -- attempting to fallback to a default font.`);
+        fontRef = PartialEvaluator.getFallbackFontDict();
       }
+
       if (this.fontCache.has(fontRef)) {
         return this.fontCache.get(fontRef);
       }
+
       font = xref.fetchIfRef(fontRef);
+
       if (!(0, _primitives.isDict)(font)) {
         return errorFont();
       }
+
       if (font.translated) {
         return font.translated;
       }
+
       var fontCapability = (0, _util.createPromiseCapability)();
       var preEvaluatedFont = this.preEvaluateFont(font);
-      var descriptor = preEvaluatedFont.descriptor;
+      const {
+        descriptor,
+        hash
+      } = preEvaluatedFont;
       var fontRefIsRef = (0, _primitives.isRef)(fontRef),
           fontID;
+
       if (fontRefIsRef) {
         fontID = fontRef.toString();
       }
-      if ((0, _primitives.isDict)(descriptor)) {
+
+      if (hash && (0, _primitives.isDict)(descriptor)) {
         if (!descriptor.fontAliases) {
           descriptor.fontAliases = Object.create(null);
         }
+
         var fontAliases = descriptor.fontAliases;
-        var hash = preEvaluatedFont.hash;
+
         if (fontAliases[hash]) {
           var aliasFontRef = fontAliases[hash].aliasRef;
+
           if (fontRefIsRef && aliasFontRef && this.fontCache.has(aliasFontRef)) {
             this.fontCache.putAlias(fontRef, aliasFontRef);
             return this.fontCache.get(fontRef);
           }
         } else {
-          fontAliases[hash] = { fontID: _fonts.Font.getFontID() };
+          fontAliases[hash] = {
+            fontID: _fonts.Font.getFontID()
+          };
         }
+
         if (fontRefIsRef) {
           fontAliases[hash].aliasRef = fontRef;
         }
+
         fontID = fontAliases[hash].fontID;
       }
+
       if (fontRefIsRef) {
         this.fontCache.put(fontRef, fontCapability.promise);
       } else {
         if (!fontID) {
           fontID = this.idFactory.createObjId();
         }
-        this.fontCache.put('id_' + fontID, fontCapability.promise);
+
+        this.fontCache.put(`id_${fontID}`, fontCapability.promise);
       }
+
       (0, _util.assert)(fontID, 'The "fontID" must be defined.');
-      font.loadedName = 'g_' + this.pdfManager.docId + '_f' + fontID;
+      font.loadedName = `${this.idFactory.getDocId()}_f${fontID}`;
       font.translated = fontCapability.promise;
       var translatedPromise;
+
       try {
         translatedPromise = this.translateFont(preEvaluatedFont);
       } catch (e) {
         translatedPromise = Promise.reject(e);
       }
+
       translatedPromise.then(function (translatedFont) {
         if (translatedFont.fontType !== undefined) {
           var xrefFontStats = xref.stats.fontTypes;
           xrefFontStats[translatedFont.fontType] = true;
         }
+
         fontCapability.resolve(new TranslatedFont(font.loadedName, translatedFont, font));
-      }).catch(function (reason) {
-        _this7.handler.send('UnsupportedFeature', { featureId: _util.UNSUPPORTED_FEATURES.font });
+      }).catch(reason => {
+        this.handler.send("UnsupportedFeature", {
+          featureId: _util.UNSUPPORTED_FEATURES.font
+        });
+
         try {
-          var descriptor = preEvaluatedFont.descriptor;
-          var fontFile3 = descriptor && descriptor.get('FontFile3');
-          var subtype = fontFile3 && fontFile3.get('Subtype');
+          var fontFile3 = descriptor && descriptor.get("FontFile3");
+          var subtype = fontFile3 && fontFile3.get("Subtype");
           var fontType = (0, _fonts.getFontType)(preEvaluatedFont.type, subtype && subtype.name);
           var xrefFontStats = xref.stats.fontTypes;
           xrefFontStats[fontType] = true;
         } catch (ex) {}
+
         fontCapability.resolve(new TranslatedFont(font.loadedName, new _fonts.ErrorFont(reason instanceof Error ? reason.message : reason), font));
       });
       return fontCapability.promise;
     },
-    buildPath: function PartialEvaluator_buildPath(operatorList, fn, args) {
+
+    buildPath(operatorList, fn, args, parsingText = false) {
       var lastIndex = operatorList.length - 1;
+
       if (!args) {
         args = [];
       }
+
       if (lastIndex < 0 || operatorList.fnArray[lastIndex] !== _util.OPS.constructPath) {
+        if (parsingText) {
+          (0, _util.warn)(`Encountered path operator "${fn}" inside of a text object.`);
+          operatorList.addOp(_util.OPS.save, null);
+        }
+
         operatorList.addOp(_util.OPS.constructPath, [[fn], args]);
+
+        if (parsingText) {
+          operatorList.addOp(_util.OPS.restore, null);
+        }
       } else {
         var opArgs = operatorList.argsArray[lastIndex];
         opArgs[0].push(fn);
         Array.prototype.push.apply(opArgs[1], args);
       }
     },
-    handleColorN: function PartialEvaluator_handleColorN(operatorList, fn, args, cs, patterns, resources, task) {
+
+    parseColorSpace({
+      cs,
+      resources
+    }) {
+      return new Promise(resolve => {
+        resolve(_colorspace.ColorSpace.parse(cs, this.xref, resources, this.pdfFunctionFactory));
+      }).catch(reason => {
+        if (reason instanceof _util.AbortException) {
+          return null;
+        }
+
+        if (this.options.ignoreErrors) {
+          this.handler.send("UnsupportedFeature", {
+            featureId: _util.UNSUPPORTED_FEATURES.unknown
+          });
+          (0, _util.warn)(`parseColorSpace - ignoring ColorSpace: "${reason}".`);
+          return null;
+        }
+
+        throw reason;
+      });
+    },
+
+    async handleColorN(operatorList, fn, args, cs, patterns, resources, task) {
       var patternName = args[args.length - 1];
       var pattern;
+
       if ((0, _primitives.isName)(patternName) && (pattern = patterns.get(patternName.name))) {
         var dict = (0, _primitives.isStream)(pattern) ? pattern.dict : pattern;
-        var typeNum = dict.get('PatternType');
+        var typeNum = dict.get("PatternType");
+
         if (typeNum === TILING_PATTERN) {
           var color = cs.base ? cs.base.getRgb(args, 0) : null;
           return this.handleTilingType(fn, color, resources, pattern, dict, operatorList, task);
         } else if (typeNum === SHADING_PATTERN) {
-          var shading = dict.get('Shading');
-          var matrix = dict.getArray('Matrix');
+          var shading = dict.get("Shading");
+          var matrix = dict.getArray("Matrix");
           pattern = _pattern.Pattern.parseShading(shading, matrix, this.xref, resources, this.handler, this.pdfFunctionFactory);
           operatorList.addOp(fn, pattern.getIR());
-          return Promise.resolve();
+          return undefined;
         }
-        return Promise.reject(new Error('Unknown PatternType: ' + typeNum));
+
+        throw new _util.FormatError(`Unknown PatternType: ${typeNum}`);
       }
-      operatorList.addOp(fn, args);
-      return Promise.resolve();
-    },
-    getOperatorList: function getOperatorList(_ref6) {
-      var _this8 = this;
 
-      var stream = _ref6.stream,
-          task = _ref6.task,
-          resources = _ref6.resources,
-          operatorList = _ref6.operatorList,
-          _ref6$initialState = _ref6.initialState,
-          initialState = _ref6$initialState === undefined ? null : _ref6$initialState;
+      throw new _util.FormatError(`Unknown PatternName: ${patternName}`);
+    },
 
+    getOperatorList({
+      stream,
+      task,
+      resources,
+      operatorList,
+      initialState = null
+    }) {
       resources = resources || _primitives.Dict.empty;
       initialState = initialState || new EvalState();
+
       if (!operatorList) {
         throw new Error('getOperatorList: missing "operatorList" parameter');
       }
+
       var self = this;
       var xref = this.xref;
+      let parsingText = false;
       var imageCache = Object.create(null);
-      var xobjs = resources.get('XObject') || _primitives.Dict.empty;
-      var patterns = resources.get('Pattern') || _primitives.Dict.empty;
+
+      var xobjs = resources.get("XObject") || _primitives.Dict.empty;
+
+      var patterns = resources.get("Pattern") || _primitives.Dict.empty;
+
       var stateManager = new StateManager(initialState);
       var preprocessor = new EvaluatorPreprocessor(stream, xref, stateManager);
       var timeSlotManager = new TimeSlotManager();
+
       function closePendingRestoreOPS(argument) {
         for (var i = 0, ii = preprocessor.savedStatesDepth; i < ii; i++) {
           operatorList.addOp(_util.OPS.restore, []);
         }
       }
+
       return new Promise(function promiseBody(resolve, reject) {
-        var next = function next(promise) {
-          promise.then(function () {
+        const next = function (promise) {
+          Promise.all([promise, operatorList.ready]).then(function () {
             try {
               promiseBody(resolve, reject);
             } catch (ex) {
@@ -842,6 +1078,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
             }
           }, reject);
         };
+
         task.ensureNotTerminated();
         timeSlotManager.reset();
         var stop,
@@ -849,69 +1086,90 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
             i,
             ii,
             cs;
+
         while (!(stop = timeSlotManager.check())) {
           operation.args = null;
+
           if (!preprocessor.read(operation)) {
             break;
           }
+
           var args = operation.args;
           var fn = operation.fn;
+
           switch (fn | 0) {
             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;
               }
+
               next(new Promise(function (resolveXObject, rejectXObject) {
                 if (!name) {
-                  throw new _util.FormatError('XObject must be referred to by name.');
+                  throw new _util.FormatError("XObject must be referred to by name.");
                 }
-                var xobj = xobjs.get(name);
+
+                const xobj = xobjs.get(name);
+
                 if (!xobj) {
                   operatorList.addOp(fn, args);
                   resolveXObject();
                   return;
                 }
+
                 if (!(0, _primitives.isStream)(xobj)) {
-                  throw new _util.FormatError('XObject should be a stream');
+                  throw new _util.FormatError("XObject should be a stream");
                 }
-                var type = xobj.dict.get('Subtype');
+
+                const type = xobj.dict.get("Subtype");
+
                 if (!(0, _primitives.isName)(type)) {
-                  throw new _util.FormatError('XObject should have a Name subtype');
+                  throw new _util.FormatError("XObject should have a Name subtype");
                 }
-                if (type.name === 'Form') {
+
+                if (type.name === "Form") {
                   stateManager.save();
                   self.buildFormXObject(resources, xobj, null, operatorList, task, stateManager.state.clone()).then(function () {
                     stateManager.restore();
                     resolveXObject();
                   }, rejectXObject);
                   return;
-                } else if (type.name === 'Image') {
+                } else if (type.name === "Image") {
                   self.buildPaintImageXObject({
-                    resources: resources,
+                    resources,
                     image: xobj,
-                    operatorList: operatorList,
+                    operatorList,
                     cacheKey: name,
-                    imageCache: imageCache
+                    imageCache
                   }).then(resolveXObject, rejectXObject);
                   return;
-                } else if (type.name === 'PS') {
-                  (0, _util.info)('Ignored XObject subtype PS');
+                } else if (type.name === "PS") {
+                  (0, _util.info)("Ignored XObject subtype PS");
                 } else {
-                  throw new _util.FormatError('Unhandled XObject subtype ' + type.name);
+                  throw new _util.FormatError(`Unhandled XObject subtype ${type.name}`);
                 }
+
                 resolveXObject();
               }).catch(function (reason) {
+                if (reason instanceof _util.AbortException) {
+                  return;
+                }
+
                 if (self.options.ignoreErrors) {
-                  self.handler.send('UnsupportedFeature', { featureId: _util.UNSUPPORTED_FEATURES.unknown });
-                  (0, _util.warn)('getOperatorList - ignoring XObject: "' + reason + '".');
+                  self.handler.send("UnsupportedFeature", {
+                    featureId: _util.UNSUPPORTED_FEATURES.unknown
+                  });
+                  (0, _util.warn)(`getOperatorList - ignoring XObject: "${reason}".`);
                   return;
                 }
+
                 throw reason;
               }));
               return;
+
             case _util.OPS.setFont:
               var fontSize = args[1];
               next(self.handleSetFont(resources, args, null, operatorList, task, stateManager.state).then(function (loadedName) {
@@ -919,155 +1177,234 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
                 operatorList.addOp(_util.OPS.setFont, [loadedName, fontSize]);
               }));
               return;
+
+            case _util.OPS.beginText:
+              parsingText = true;
+              break;
+
+            case _util.OPS.endText:
+              parsingText = false;
+              break;
+
             case _util.OPS.endInlineImage:
               var cacheKey = args[0].cacheKey;
+
               if (cacheKey) {
                 var cacheEntry = imageCache[cacheKey];
+
                 if (cacheEntry !== undefined) {
                   operatorList.addOp(cacheEntry.fn, cacheEntry.args);
                   args = null;
                   continue;
                 }
               }
+
               next(self.buildPaintImageXObject({
-                resources: resources,
+                resources,
                 image: args[0],
                 isInline: true,
-                operatorList: operatorList,
-                cacheKey: cacheKey,
-                imageCache: imageCache
+                operatorList,
+                cacheKey,
+                imageCache
               }));
               return;
+
             case _util.OPS.showText:
+              if (!stateManager.state.font) {
+                self.ensureStateFont(stateManager.state);
+                continue;
+              }
+
               args[0] = self.handleText(args[0], stateManager.state);
               break;
+
             case _util.OPS.showSpacedText:
+              if (!stateManager.state.font) {
+                self.ensureStateFont(stateManager.state);
+                continue;
+              }
+
               var arr = args[0];
               var combinedGlyphs = [];
               var arrLength = arr.length;
               var state = stateManager.state;
+
               for (i = 0; i < arrLength; ++i) {
                 var arrItem = arr[i];
+
                 if ((0, _util.isString)(arrItem)) {
                   Array.prototype.push.apply(combinedGlyphs, self.handleText(arrItem, state));
                 } else if ((0, _util.isNum)(arrItem)) {
                   combinedGlyphs.push(arrItem);
                 }
               }
+
               args[0] = combinedGlyphs;
               fn = _util.OPS.showText;
               break;
+
             case _util.OPS.nextLineShowText:
+              if (!stateManager.state.font) {
+                self.ensureStateFont(stateManager.state);
+                continue;
+              }
+
               operatorList.addOp(_util.OPS.nextLine);
               args[0] = self.handleText(args[0], stateManager.state);
               fn = _util.OPS.showText;
               break;
+
             case _util.OPS.nextLineSetSpacingShowText:
+              if (!stateManager.state.font) {
+                self.ensureStateFont(stateManager.state);
+                continue;
+              }
+
               operatorList.addOp(_util.OPS.nextLine);
               operatorList.addOp(_util.OPS.setWordSpacing, [args.shift()]);
               operatorList.addOp(_util.OPS.setCharSpacing, [args.shift()]);
               args[0] = self.handleText(args[0], stateManager.state);
               fn = _util.OPS.showText;
               break;
+
             case _util.OPS.setTextRenderingMode:
               stateManager.state.textRenderingMode = args[0];
               break;
+
             case _util.OPS.setFillColorSpace:
-              stateManager.state.fillColorSpace = _colorspace.ColorSpace.parse(args[0], xref, resources, self.pdfFunctionFactory);
-              continue;
+              next(self.parseColorSpace({
+                cs: args[0],
+                resources
+              }).then(function (colorSpace) {
+                if (colorSpace) {
+                  stateManager.state.fillColorSpace = colorSpace;
+                }
+              }));
+              return;
+
             case _util.OPS.setStrokeColorSpace:
-              stateManager.state.strokeColorSpace = _colorspace.ColorSpace.parse(args[0], xref, resources, self.pdfFunctionFactory);
-              continue;
+              next(self.parseColorSpace({
+                cs: args[0],
+                resources
+              }).then(function (colorSpace) {
+                if (colorSpace) {
+                  stateManager.state.strokeColorSpace = colorSpace;
+                }
+              }));
+              return;
+
             case _util.OPS.setFillColor:
               cs = stateManager.state.fillColorSpace;
               args = cs.getRgb(args, 0);
               fn = _util.OPS.setFillRGBColor;
               break;
+
             case _util.OPS.setStrokeColor:
               cs = stateManager.state.strokeColorSpace;
               args = cs.getRgb(args, 0);
               fn = _util.OPS.setStrokeRGBColor;
               break;
+
             case _util.OPS.setFillGray:
               stateManager.state.fillColorSpace = _colorspace.ColorSpace.singletons.gray;
               args = _colorspace.ColorSpace.singletons.gray.getRgb(args, 0);
               fn = _util.OPS.setFillRGBColor;
               break;
+
             case _util.OPS.setStrokeGray:
               stateManager.state.strokeColorSpace = _colorspace.ColorSpace.singletons.gray;
               args = _colorspace.ColorSpace.singletons.gray.getRgb(args, 0);
               fn = _util.OPS.setStrokeRGBColor;
               break;
+
             case _util.OPS.setFillCMYKColor:
               stateManager.state.fillColorSpace = _colorspace.ColorSpace.singletons.cmyk;
               args = _colorspace.ColorSpace.singletons.cmyk.getRgb(args, 0);
               fn = _util.OPS.setFillRGBColor;
               break;
+
             case _util.OPS.setStrokeCMYKColor:
               stateManager.state.strokeColorSpace = _colorspace.ColorSpace.singletons.cmyk;
               args = _colorspace.ColorSpace.singletons.cmyk.getRgb(args, 0);
               fn = _util.OPS.setStrokeRGBColor;
               break;
+
             case _util.OPS.setFillRGBColor:
               stateManager.state.fillColorSpace = _colorspace.ColorSpace.singletons.rgb;
               args = _colorspace.ColorSpace.singletons.rgb.getRgb(args, 0);
               break;
+
             case _util.OPS.setStrokeRGBColor:
               stateManager.state.strokeColorSpace = _colorspace.ColorSpace.singletons.rgb;
               args = _colorspace.ColorSpace.singletons.rgb.getRgb(args, 0);
               break;
+
             case _util.OPS.setFillColorN:
               cs = stateManager.state.fillColorSpace;
-              if (cs.name === 'Pattern') {
+
+              if (cs.name === "Pattern") {
                 next(self.handleColorN(operatorList, _util.OPS.setFillColorN, args, cs, patterns, resources, task));
                 return;
               }
+
               args = cs.getRgb(args, 0);
               fn = _util.OPS.setFillRGBColor;
               break;
+
             case _util.OPS.setStrokeColorN:
               cs = stateManager.state.strokeColorSpace;
-              if (cs.name === 'Pattern') {
+
+              if (cs.name === "Pattern") {
                 next(self.handleColorN(operatorList, _util.OPS.setStrokeColorN, args, cs, patterns, resources, task));
                 return;
               }
+
               args = cs.getRgb(args, 0);
               fn = _util.OPS.setStrokeRGBColor;
               break;
+
             case _util.OPS.shadingFill:
-              var shadingRes = resources.get('Shading');
+              var shadingRes = resources.get("Shading");
+
               if (!shadingRes) {
-                throw new _util.FormatError('No shading resource found');
+                throw new _util.FormatError("No shading resource found");
               }
+
               var shading = shadingRes.get(args[0].name);
+
               if (!shading) {
-                throw new _util.FormatError('No shading object found');
+                throw new _util.FormatError("No shading object found");
               }
+
               var shadingFill = _pattern.Pattern.parseShading(shading, null, xref, resources, self.handler, self.pdfFunctionFactory);
+
               var patternIR = shadingFill.getIR();
               args = [patternIR];
               fn = _util.OPS.shadingFill;
               break;
+
             case _util.OPS.setGState:
               var dictName = args[0];
-              var extGState = resources.get('ExtGState');
+              var extGState = resources.get("ExtGState");
+
               if (!(0, _primitives.isDict)(extGState) || !extGState.has(dictName.name)) {
                 break;
               }
+
               var gState = extGState.get(dictName.name);
               next(self.setGState(resources, gState, operatorList, task, stateManager));
               return;
+
             case _util.OPS.moveTo:
             case _util.OPS.lineTo:
             case _util.OPS.curveTo:
             case _util.OPS.curveTo2:
             case _util.OPS.curveTo3:
             case _util.OPS.closePath:
-              self.buildPath(operatorList, fn, args);
-              continue;
             case _util.OPS.rectangle:
-              self.buildPath(operatorList, fn, args);
+              self.buildPath(operatorList, fn, args, parsingText);
               continue;
+
             case _util.OPS.markPoint:
             case _util.OPS.markPointProps:
             case _util.OPS.beginMarkedContent:
@@ -1076,6 +1413,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
             case _util.OPS.beginCompat:
             case _util.OPS.endCompat:
               continue;
+
             default:
               if (args !== null) {
                 for (i = 0, ii = args.length; i < ii; i++) {
@@ -1083,46 +1421,53 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
                     break;
                   }
                 }
+
                 if (i < ii) {
-                  (0, _util.warn)('getOperatorList - ignoring operator: ' + fn);
+                  (0, _util.warn)("getOperatorList - ignoring operator: " + fn);
                   continue;
                 }
               }
+
           }
+
           operatorList.addOp(fn, args);
         }
+
         if (stop) {
           next(deferred);
           return;
         }
+
         closePendingRestoreOPS();
         resolve();
-      }).catch(function (reason) {
-        if (_this8.options.ignoreErrors) {
-          _this8.handler.send('UnsupportedFeature', { featureId: _util.UNSUPPORTED_FEATURES.unknown });
-          (0, _util.warn)('getOperatorList - ignoring errors during "' + task.name + '" ' + ('task: "' + reason + '".'));
+      }).catch(reason => {
+        if (reason instanceof _util.AbortException) {
+          return;
+        }
+
+        if (this.options.ignoreErrors) {
+          this.handler.send("UnsupportedFeature", {
+            featureId: _util.UNSUPPORTED_FEATURES.unknown
+          });
+          (0, _util.warn)(`getOperatorList - ignoring errors during "${task.name}" ` + `task: "${reason}".`);
           closePendingRestoreOPS();
           return;
         }
+
         throw reason;
       });
     },
-    getTextContent: function getTextContent(_ref7) {
-      var _this9 = this;
-
-      var stream = _ref7.stream,
-          task = _ref7.task,
-          resources = _ref7.resources,
-          _ref7$stateManager = _ref7.stateManager,
-          stateManager = _ref7$stateManager === undefined ? null : _ref7$stateManager,
-          _ref7$normalizeWhites = _ref7.normalizeWhitespace,
-          normalizeWhitespace = _ref7$normalizeWhites === undefined ? false : _ref7$normalizeWhites,
-          _ref7$combineTextItem = _ref7.combineTextItems,
-          combineTextItems = _ref7$combineTextItem === undefined ? false : _ref7$combineTextItem,
-          sink = _ref7.sink,
-          _ref7$seenStyles = _ref7.seenStyles,
-          seenStyles = _ref7$seenStyles === undefined ? Object.create(null) : _ref7$seenStyles;
 
+    getTextContent({
+      stream,
+      task,
+      resources,
+      stateManager = null,
+      normalizeWhitespace = false,
+      combineTextItems = false,
+      sink,
+      seenStyles = Object.create(null)
+    }) {
       resources = resources || _primitives.Dict.empty;
       stateManager = stateManager || new StateManager(new TextState());
       var WhitespaceRegexp = /\s/g;
@@ -1156,31 +1501,39 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
       var skipEmptyXObjs = Object.create(null);
       var preprocessor = new EvaluatorPreprocessor(stream, xref, stateManager);
       var textState;
+
       function ensureTextContentItem() {
         if (textContentItem.initialized) {
           return textContentItem;
         }
+
         var font = textState.font;
+
         if (!(font.loadedName in seenStyles)) {
           seenStyles[font.loadedName] = true;
           textContent.styles[font.loadedName] = {
             fontFamily: font.fallbackName,
             ascent: font.ascent,
             descent: font.descent,
-            vertical: font.vertical
+            vertical: !!font.vertical
           };
         }
+
         textContentItem.fontName = font.loadedName;
         var tsm = [textState.fontSize * textState.textHScale, 0, 0, textState.fontSize, 0, textState.textRise];
-        if (font.isType3Font && textState.fontMatrix !== _util.FONT_IDENTITY_MATRIX && textState.fontSize === 1) {
-          var glyphHeight = font.bbox[3] - font.bbox[1];
+
+        if (font.isType3Font && textState.fontSize <= 1 && !(0, _util.isArrayEqual)(textState.fontMatrix, _util.FONT_IDENTITY_MATRIX)) {
+          const glyphHeight = font.bbox[3] - font.bbox[1];
+
           if (glyphHeight > 0) {
-            glyphHeight = glyphHeight * textState.fontMatrix[3];
-            tsm[3] *= glyphHeight;
+            tsm[3] *= glyphHeight * textState.fontMatrix[3];
           }
         }
+
         var trm = _util.Util.transform(textState.ctm, _util.Util.transform(textState.textMatrix, tsm));
+
         textContentItem.transform = trm;
+
         if (!font.vertical) {
           textContentItem.width = 0;
           textContentItem.height = Math.sqrt(trm[2] * trm[2] + trm[3] * trm[3]);
@@ -1190,6 +1543,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
           textContentItem.height = 0;
           textContentItem.vertical = true;
         }
+
         var a = textState.textLineMatrix[0];
         var b = textState.textLineMatrix[1];
         var scaleLineX = Math.sqrt(a * a + b * b);
@@ -1200,6 +1554,7 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
         textContentItem.lastAdvanceWidth = 0;
         textContentItem.lastAdvanceHeight = 0;
         var spaceWidth = font.spaceWidth / 1000 * textState.fontSize;
+
         if (spaceWidth) {
           textContentItem.spaceWidth = spaceWidth;
           textContentItem.fakeSpaceMin = spaceWidth * SPACE_FACTOR;
@@ -1213,20 +1568,25 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
           textContentItem.fakeMultiSpaceMax = 0;
           textContentItem.textRunBreakAllowed = false;
         }
+
         textContentItem.initialized = true;
         return textContentItem;
       }
+
       function replaceWhitespace(str) {
         var i = 0,
             ii = str.length,
             code;
-        while (i < ii && (code = str.charCodeAt(i)) >= 0x20 && code <= 0x7F) {
+
+        while (i < ii && (code = str.charCodeAt(i)) >= 0x20 && code <= 0x7f) {
           i++;
         }
-        return i < ii ? str.replace(WhitespaceRegexp, ' ') : str;
+
+        return i < ii ? str.replace(WhitespaceRegexp, " ") : str;
       }
+
       function runBidiTransform(textChunk) {
-        var str = textChunk.str.join('');
+        var str = textChunk.str.join("");
         var bidiResult = (0, _bidi.bidi)(str, -1, textChunk.vertical);
         return {
           str: normalizeWhitespace ? replaceWhitespace(bidiResult.str) : bidiResult.str,
@@ -1237,42 +1597,53 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
           fontName: textChunk.fontName
         };
       }
+
       function handleSetFont(fontName, fontRef) {
         return self.loadFont(fontName, fontRef, resources).then(function (translated) {
           textState.font = translated.font;
           textState.fontMatrix = translated.font.fontMatrix || _util.FONT_IDENTITY_MATRIX;
         });
       }
+
       function buildTextContentItem(chars) {
         var font = textState.font;
         var textChunk = ensureTextContentItem();
         var width = 0;
         var height = 0;
         var glyphs = font.charsToGlyphs(chars);
+
         for (var i = 0; i < glyphs.length; i++) {
           var glyph = glyphs[i];
           var glyphWidth = null;
+
           if (font.vertical && glyph.vmetric) {
             glyphWidth = glyph.vmetric[0];
           } else {
             glyphWidth = glyph.width;
           }
+
           var glyphUnicode = glyph.unicode;
           var NormalizedUnicodes = (0, _unicode.getNormalizedUnicodes)();
+
           if (NormalizedUnicodes[glyphUnicode] !== undefined) {
             glyphUnicode = NormalizedUnicodes[glyphUnicode];
           }
+
           glyphUnicode = (0, _unicode.reverseIfRtl)(glyphUnicode);
           var charSpacing = textState.charSpacing;
+
           if (glyph.isSpace) {
             var wordSpacing = textState.wordSpacing;
             charSpacing += wordSpacing;
+
             if (wordSpacing > 0) {
               addFakeSpaces(wordSpacing, textChunk.str);
             }
           }
+
           var tx = 0;
           var ty = 0;
+
           if (!font.vertical) {
             var w0 = glyphWidth * textState.fontMatrix[0];
             tx = (w0 * textState.fontSize + charSpacing) * textState.textHScale;
@@ -1282,9 +1653,11 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
             ty = w1 * textState.fontSize + charSpacing;
             height += ty;
           }
+
           textState.translateTextMatrix(tx, ty);
           textChunk.str.push(glyphUnicode);
         }
+
         if (!font.vertical) {
           textChunk.lastAdvanceWidth = width;
           textChunk.width += width;
@@ -1292,42 +1665,56 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
           textChunk.lastAdvanceHeight = height;
           textChunk.height += Math.abs(height);
         }
+
         return textChunk;
       }
+
       function addFakeSpaces(width, strBuf) {
         if (width < textContentItem.fakeSpaceMin) {
           return;
         }
+
         if (width < textContentItem.fakeMultiSpaceMin) {
-          strBuf.push(' ');
+          strBuf.push(" ");
           return;
         }
+
         var fakeSpaces = Math.round(width / textContentItem.spaceWidth);
+
         while (fakeSpaces-- > 0) {
-          strBuf.push(' ');
+          strBuf.push(" ");
         }
       }
+
       function flushTextContentItem() {
         if (!textContentItem.initialized) {
           return;
         }
-        textContentItem.width *= textContentItem.textAdvanceScale;
-        textContentItem.height *= textContentItem.textAdvanceScale;
+
+        if (!textContentItem.vertical) {
+          textContentItem.width *= textContentItem.textAdvanceScale;
+        } else {
+          textContentItem.height *= textContentItem.textAdvanceScale;
+        }
+
         textContent.items.push(runBidiTransform(textContentItem));
         textContentItem.initialized = false;
         textContentItem.str.length = 0;
       }
+
       function enqueueChunk() {
-        var length = textContent.items.length;
+        const length = textContent.items.length;
+
         if (length > 0) {
           sink.enqueue(textContent, length);
           textContent.items = [];
           textContent.styles = Object.create(null);
         }
       }
+
       var timeSlotManager = new TimeSlotManager();
       return new Promise(function promiseBody(resolve, reject) {
-        var next = function next(promise) {
+        const next = function (promise) {
           enqueueChunk();
           Promise.all([promise, sink.ready]).then(function () {
             try {
@@ -1337,48 +1724,60 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
             }
           }, reject);
         };
+
         task.ensureNotTerminated();
         timeSlotManager.reset();
         var stop,
             operation = {},
             args = [];
+
         while (!(stop = timeSlotManager.check())) {
           args.length = 0;
           operation.args = args;
+
           if (!preprocessor.read(operation)) {
             break;
           }
+
           textState = stateManager.state;
           var fn = operation.fn;
           args = operation.args;
           var advance, diff;
+
           switch (fn | 0) {
             case _util.OPS.setFont:
               var fontNameArg = args[0].name,
                   fontSizeArg = args[1];
+
               if (textState.font && fontNameArg === textState.fontName && fontSizeArg === textState.fontSize) {
                 break;
               }
+
               flushTextContentItem();
               textState.fontName = fontNameArg;
               textState.fontSize = fontSizeArg;
               next(handleSetFont(fontNameArg, null));
               return;
+
             case _util.OPS.setTextRise:
               flushTextContentItem();
               textState.textRise = args[0];
               break;
+
             case _util.OPS.setHScale:
               flushTextContentItem();
               textState.textHScale = args[0] / 100;
               break;
+
             case _util.OPS.setLeading:
               flushTextContentItem();
               textState.leading = args[0];
               break;
+
             case _util.OPS.moveText:
               var isSameTextLine = !textState.font ? false : (textState.font.vertical ? args[0] : args[1]) === 0;
               advance = args[0] - args[1];
+
               if (combineTextItems && isSameTextLine && textContentItem.initialized && advance > 0 && advance <= textContentItem.fakeMultiSpaceMax) {
                 textState.translateTextLineMatrix(args[0], args[1]);
                 textContentItem.width += args[0] - textContentItem.lastAdvanceWidth;
@@ -1387,22 +1786,27 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
                 addFakeSpaces(diff, textContentItem.str);
                 break;
               }
+
               flushTextContentItem();
               textState.translateTextLineMatrix(args[0], args[1]);
               textState.textMatrix = textState.textLineMatrix.slice();
               break;
+
             case _util.OPS.setLeadingMoveText:
               flushTextContentItem();
               textState.leading = -args[1];
               textState.translateTextLineMatrix(args[0], args[1]);
               textState.textMatrix = textState.textLineMatrix.slice();
               break;
+
             case _util.OPS.nextLine:
               flushTextContentItem();
               textState.carriageReturn();
               break;
+
             case _util.OPS.setTextMatrix:
               advance = textState.calcTextLineMatrixAdvance(args[0], args[1], args[2], args[3], args[4], args[5]);
+
               if (combineTextItems && advance !== null && textContentItem.initialized && advance.value > 0 && advance.value <= textContentItem.fakeMultiSpaceMax) {
                 textState.translateTextLineMatrix(advance.width, advance.height);
                 textContentItem.width += advance.width - textContentItem.lastAdvanceWidth;
@@ -1411,35 +1815,48 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
                 addFakeSpaces(diff, textContentItem.str);
                 break;
               }
+
               flushTextContentItem();
               textState.setTextMatrix(args[0], args[1], args[2], args[3], args[4], args[5]);
               textState.setTextLineMatrix(args[0], args[1], args[2], args[3], args[4], args[5]);
               break;
+
             case _util.OPS.setCharSpacing:
               textState.charSpacing = args[0];
               break;
+
             case _util.OPS.setWordSpacing:
               textState.wordSpacing = args[0];
               break;
+
             case _util.OPS.beginText:
               flushTextContentItem();
               textState.textMatrix = _util.IDENTITY_MATRIX.slice();
               textState.textLineMatrix = _util.IDENTITY_MATRIX.slice();
               break;
+
             case _util.OPS.showSpacedText:
+              if (!stateManager.state.font) {
+                self.ensureStateFont(stateManager.state);
+                continue;
+              }
+
               var items = args[0];
               var offset;
+
               for (var j = 0, jj = items.length; j < jj; j++) {
-                if (typeof items[j] === 'string') {
+                if (typeof items[j] === "string") {
                   buildTextContentItem(items[j]);
                 } else if ((0, _util.isNum)(items[j])) {
                   ensureTextContentItem();
                   advance = items[j] * textState.fontSize / 1000;
                   var breakTextRun = false;
+
                   if (textState.font.vertical) {
                     offset = advance;
                     textState.translateTextMatrix(0, offset);
                     breakTextRun = textContentItem.textRunBreakAllowed && advance > textContentItem.fakeMultiSpaceMax;
+
                     if (!breakTextRun) {
                       textContentItem.height += offset;
                     }
@@ -1448,10 +1865,12 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
                     offset = advance * textState.textHScale;
                     textState.translateTextMatrix(offset, 0);
                     breakTextRun = textContentItem.textRunBreakAllowed && advance > textContentItem.fakeMultiSpaceMax;
+
                     if (!breakTextRun) {
                       textContentItem.width += offset;
                     }
                   }
+
                   if (breakTextRun) {
                     flushTextContentItem();
                   } else if (advance > 0) {
@@ -1459,62 +1878,96 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
                   }
                 }
               }
+
               break;
+
             case _util.OPS.showText:
+              if (!stateManager.state.font) {
+                self.ensureStateFont(stateManager.state);
+                continue;
+              }
+
               buildTextContentItem(args[0]);
               break;
+
             case _util.OPS.nextLineShowText:
+              if (!stateManager.state.font) {
+                self.ensureStateFont(stateManager.state);
+                continue;
+              }
+
               flushTextContentItem();
               textState.carriageReturn();
               buildTextContentItem(args[0]);
               break;
+
             case _util.OPS.nextLineSetSpacingShowText:
+              if (!stateManager.state.font) {
+                self.ensureStateFont(stateManager.state);
+                continue;
+              }
+
               flushTextContentItem();
               textState.wordSpacing = args[0];
               textState.charSpacing = args[1];
               textState.carriageReturn();
               buildTextContentItem(args[2]);
               break;
+
             case _util.OPS.paintXObject:
               flushTextContentItem();
+
               if (!xobjs) {
-                xobjs = resources.get('XObject') || _primitives.Dict.empty;
+                xobjs = resources.get("XObject") || _primitives.Dict.empty;
               }
+
               var name = args[0].name;
+
               if (name && skipEmptyXObjs[name] !== undefined) {
                 break;
               }
+
               next(new Promise(function (resolveXObject, rejectXObject) {
                 if (!name) {
-                  throw new _util.FormatError('XObject must be referred to by name.');
+                  throw new _util.FormatError("XObject must be referred to by name.");
                 }
-                var xobj = xobjs.get(name);
+
+                const xobj = xobjs.get(name);
+
                 if (!xobj) {
                   resolveXObject();
                   return;
                 }
+
                 if (!(0, _primitives.isStream)(xobj)) {
-                  throw new _util.FormatError('XObject should be a stream');
+                  throw new _util.FormatError("XObject should be a stream");
                 }
-                var type = xobj.dict.get('Subtype');
+
+                const type = xobj.dict.get("Subtype");
+
                 if (!(0, _primitives.isName)(type)) {
-                  throw new _util.FormatError('XObject should have a Name subtype');
+                  throw new _util.FormatError("XObject should have a Name subtype");
                 }
-                if (type.name !== 'Form') {
+
+                if (type.name !== "Form") {
                   skipEmptyXObjs[name] = true;
                   resolveXObject();
                   return;
                 }
-                var currentState = stateManager.state.clone();
-                var xObjStateManager = new StateManager(currentState);
-                var matrix = xobj.dict.getArray('Matrix');
+
+                const currentState = stateManager.state.clone();
+                const xObjStateManager = new StateManager(currentState);
+                const matrix = xobj.dict.getArray("Matrix");
+
                 if (Array.isArray(matrix) && matrix.length === 6) {
                   xObjStateManager.transform(matrix);
                 }
+
                 enqueueChunk();
-                var sinkWrapper = {
+                const sinkWrapper = {
                   enqueueInvoked: false,
-                  enqueue: function enqueue(chunk, size) {
+
+                  enqueue(chunk, size) {
                     this.enqueueInvoked = true;
                     sink.enqueue(chunk, size);
                   },
@@ -1522,254 +1975,332 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
                   get desiredSize() {
                     return sink.desiredSize;
                   },
+
                   get ready() {
                     return sink.ready;
                   }
+
                 };
                 self.getTextContent({
                   stream: xobj,
-                  task: task,
-                  resources: xobj.dict.get('Resources') || resources,
+                  task,
+                  resources: xobj.dict.get("Resources") || resources,
                   stateManager: xObjStateManager,
-                  normalizeWhitespace: normalizeWhitespace,
-                  combineTextItems: combineTextItems,
+                  normalizeWhitespace,
+                  combineTextItems,
                   sink: sinkWrapper,
-                  seenStyles: seenStyles
+                  seenStyles
                 }).then(function () {
                   if (!sinkWrapper.enqueueInvoked) {
                     skipEmptyXObjs[name] = true;
                   }
+
                   resolveXObject();
                 }, rejectXObject);
               }).catch(function (reason) {
                 if (reason instanceof _util.AbortException) {
                   return;
                 }
+
                 if (self.options.ignoreErrors) {
-                  (0, _util.warn)('getTextContent - ignoring XObject: "' + reason + '".');
+                  (0, _util.warn)(`getTextContent - ignoring XObject: "${reason}".`);
                   return;
                 }
+
                 throw reason;
               }));
               return;
+
             case _util.OPS.setGState:
               flushTextContentItem();
               var dictName = args[0];
-              var extGState = resources.get('ExtGState');
+              var extGState = resources.get("ExtGState");
+
               if (!(0, _primitives.isDict)(extGState) || !(0, _primitives.isName)(dictName)) {
                 break;
               }
+
               var gState = extGState.get(dictName.name);
+
               if (!(0, _primitives.isDict)(gState)) {
                 break;
               }
-              var gStateFont = gState.get('Font');
+
+              var gStateFont = gState.get("Font");
+
               if (gStateFont) {
                 textState.fontName = null;
                 textState.fontSize = gStateFont[1];
                 next(handleSetFont(null, gStateFont[0]));
                 return;
               }
+
               break;
           }
+
           if (textContent.items.length >= sink.desiredSize) {
             stop = true;
             break;
           }
         }
+
         if (stop) {
           next(deferred);
           return;
         }
+
         flushTextContentItem();
         enqueueChunk();
         resolve();
-      }).catch(function (reason) {
+      }).catch(reason => {
         if (reason instanceof _util.AbortException) {
           return;
         }
-        if (_this9.options.ignoreErrors) {
-          (0, _util.warn)('getTextContent - ignoring errors during "' + task.name + '" ' + ('task: "' + reason + '".'));
+
+        if (this.options.ignoreErrors) {
+          (0, _util.warn)(`getTextContent - ignoring errors during "${task.name}" ` + `task: "${reason}".`);
           flushTextContentItem();
           enqueueChunk();
           return;
         }
+
         throw reason;
       });
     },
 
     extractDataStructures: function PartialEvaluator_extractDataStructures(dict, baseDict, properties) {
-      var _this10 = this;
-
-      var xref = this.xref;
-      var toUnicode = dict.get('ToUnicode') || baseDict.get('ToUnicode');
+      const xref = this.xref;
+      let cidToGidBytes;
+      var toUnicode = dict.get("ToUnicode") || baseDict.get("ToUnicode");
       var toUnicodePromise = toUnicode ? this.readToUnicode(toUnicode) : Promise.resolve(undefined);
+
       if (properties.composite) {
-        var cidSystemInfo = dict.get('CIDSystemInfo');
+        var cidSystemInfo = dict.get("CIDSystemInfo");
+
         if ((0, _primitives.isDict)(cidSystemInfo)) {
           properties.cidSystemInfo = {
-            registry: (0, _util.stringToPDFString)(cidSystemInfo.get('Registry')),
-            ordering: (0, _util.stringToPDFString)(cidSystemInfo.get('Ordering')),
-            supplement: cidSystemInfo.get('Supplement')
+            registry: (0, _util.stringToPDFString)(cidSystemInfo.get("Registry")),
+            ordering: (0, _util.stringToPDFString)(cidSystemInfo.get("Ordering")),
+            supplement: cidSystemInfo.get("Supplement")
           };
         }
-        var cidToGidMap = dict.get('CIDToGIDMap');
+
+        var cidToGidMap = dict.get("CIDToGIDMap");
+
         if ((0, _primitives.isStream)(cidToGidMap)) {
-          properties.cidToGidMap = this.readCidToGidMap(cidToGidMap);
+          cidToGidBytes = cidToGidMap.getBytes();
         }
       }
+
       var differences = [];
       var baseEncodingName = null;
       var encoding;
-      if (dict.has('Encoding')) {
-        encoding = dict.get('Encoding');
+
+      if (dict.has("Encoding")) {
+        encoding = dict.get("Encoding");
+
         if ((0, _primitives.isDict)(encoding)) {
-          baseEncodingName = encoding.get('BaseEncoding');
+          baseEncodingName = encoding.get("BaseEncoding");
           baseEncodingName = (0, _primitives.isName)(baseEncodingName) ? baseEncodingName.name : null;
-          if (encoding.has('Differences')) {
-            var diffEncoding = encoding.get('Differences');
+
+          if (encoding.has("Differences")) {
+            var diffEncoding = encoding.get("Differences");
             var index = 0;
+
             for (var j = 0, jj = diffEncoding.length; j < jj; j++) {
               var data = xref.fetchIfRef(diffEncoding[j]);
+
               if ((0, _util.isNum)(data)) {
                 index = data;
               } else if ((0, _primitives.isName)(data)) {
                 differences[index++] = data.name;
               } else {
-                throw new _util.FormatError('Invalid entry in \'Differences\' array: ' + data);
+                throw new _util.FormatError(`Invalid entry in 'Differences' array: ${data}`);
               }
             }
           }
         } else if ((0, _primitives.isName)(encoding)) {
           baseEncodingName = encoding.name;
         } else {
-          throw new _util.FormatError('Encoding is not a Name nor a Dict');
+          throw new _util.FormatError("Encoding is not a Name nor a Dict");
         }
-        if (baseEncodingName !== 'MacRomanEncoding' && baseEncodingName !== 'MacExpertEncoding' && baseEncodingName !== 'WinAnsiEncoding') {
+
+        if (baseEncodingName !== "MacRomanEncoding" && baseEncodingName !== "MacExpertEncoding" && baseEncodingName !== "WinAnsiEncoding") {
           baseEncodingName = null;
         }
       }
+
       if (baseEncodingName) {
         properties.defaultEncoding = (0, _encodings.getEncoding)(baseEncodingName).slice();
       } else {
         var isSymbolicFont = !!(properties.flags & _fonts.FontFlags.Symbolic);
         var isNonsymbolicFont = !!(properties.flags & _fonts.FontFlags.Nonsymbolic);
         encoding = _encodings.StandardEncoding;
-        if (properties.type === 'TrueType' && !isNonsymbolicFont) {
+
+        if (properties.type === "TrueType" && !isNonsymbolicFont) {
           encoding = _encodings.WinAnsiEncoding;
         }
+
         if (isSymbolicFont) {
           encoding = _encodings.MacRomanEncoding;
+
           if (!properties.file) {
             if (/Symbol/i.test(properties.name)) {
               encoding = _encodings.SymbolSetEncoding;
-            } else if (/Dingbats/i.test(properties.name)) {
+            } else if (/Dingbats|Wingdings/i.test(properties.name)) {
               encoding = _encodings.ZapfDingbatsEncoding;
             }
           }
         }
+
         properties.defaultEncoding = encoding;
       }
+
       properties.differences = differences;
       properties.baseEncodingName = baseEncodingName;
       properties.hasEncoding = !!baseEncodingName || differences.length > 0;
       properties.dict = dict;
-      return toUnicodePromise.then(function (toUnicode) {
+      return toUnicodePromise.then(toUnicode => {
         properties.toUnicode = toUnicode;
-        return _this10.buildToUnicode(properties);
-      }).then(function (toUnicode) {
+        return this.buildToUnicode(properties);
+      }).then(toUnicode => {
         properties.toUnicode = toUnicode;
+
+        if (cidToGidBytes) {
+          properties.cidToGidMap = this.readCidToGidMap(cidToGidBytes, toUnicode);
+        }
+
         return properties;
       });
     },
-    _buildSimpleFontToUnicode: function _buildSimpleFontToUnicode(properties) {
-      (0, _util.assert)(!properties.composite, 'Must be a simple font.');
-      var toUnicode = [],
-          charcode = void 0,
-          glyphName = void 0;
-      var encoding = properties.defaultEncoding.slice();
-      var baseEncodingName = properties.baseEncodingName;
-      var differences = properties.differences;
-      for (charcode in differences) {
-        glyphName = differences[charcode];
-        if (glyphName === '.notdef') {
+
+    _buildSimpleFontToUnicode(properties, forceGlyphs = false) {
+      (0, _util.assert)(!properties.composite, "Must be a simple font.");
+      const toUnicode = [];
+      const encoding = properties.defaultEncoding.slice();
+      const baseEncodingName = properties.baseEncodingName;
+      const differences = properties.differences;
+
+      for (const charcode in differences) {
+        const glyphName = differences[charcode];
+
+        if (glyphName === ".notdef") {
           continue;
         }
+
         encoding[charcode] = glyphName;
       }
-      var glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();
-      for (charcode in encoding) {
-        glyphName = encoding[charcode];
-        if (glyphName === '') {
+
+      const glyphsUnicodeMap = (0, _glyphlist.getGlyphsUnicode)();
+
+      for (const charcode in encoding) {
+        let glyphName = encoding[charcode];
+
+        if (glyphName === "") {
           continue;
         } else if (glyphsUnicodeMap[glyphName] === undefined) {
-          var code = 0;
+          let code = 0;
+
           switch (glyphName[0]) {
-            case 'G':
+            case "G":
               if (glyphName.length === 3) {
                 code = parseInt(glyphName.substring(1), 16);
               }
+
               break;
-            case 'g':
+
+            case "g":
               if (glyphName.length === 5) {
                 code = parseInt(glyphName.substring(1), 16);
               }
+
               break;
-            case 'C':
-            case 'c':
-              if (glyphName.length >= 3) {
-                code = +glyphName.substring(1);
+
+            case "C":
+            case "c":
+              if (glyphName.length >= 3 && glyphName.length <= 4) {
+                const codeStr = glyphName.substring(1);
+
+                if (forceGlyphs) {
+                  code = parseInt(codeStr, 16);
+                  break;
+                }
+
+                code = +codeStr;
+
+                if (Number.isNaN(code) && Number.isInteger(parseInt(codeStr, 16))) {
+                  return this._buildSimpleFontToUnicode(properties, true);
+                }
               }
+
               break;
+
             default:
-              var unicode = (0, _unicode.getUnicodeForGlyph)(glyphName, glyphsUnicodeMap);
+              const unicode = (0, _unicode.getUnicodeForGlyph)(glyphName, glyphsUnicodeMap);
+
               if (unicode !== -1) {
                 code = unicode;
               }
+
           }
-          if (code) {
+
+          if (code > 0 && Number.isInteger(code)) {
             if (baseEncodingName && code === +charcode) {
-              var baseEncoding = (0, _encodings.getEncoding)(baseEncodingName);
+              const baseEncoding = (0, _encodings.getEncoding)(baseEncodingName);
+
               if (baseEncoding && (glyphName = baseEncoding[charcode])) {
                 toUnicode[charcode] = String.fromCharCode(glyphsUnicodeMap[glyphName]);
                 continue;
               }
             }
-            toUnicode[charcode] = String.fromCharCode(code);
+
+            toUnicode[charcode] = String.fromCodePoint(code);
           }
+
           continue;
         }
+
         toUnicode[charcode] = String.fromCharCode(glyphsUnicodeMap[glyphName]);
       }
+
       return new _fonts.ToUnicodeMap(toUnicode);
     },
-    buildToUnicode: function buildToUnicode(properties) {
+
+    buildToUnicode(properties) {
       properties.hasIncludedToUnicodeMap = !!properties.toUnicode && properties.toUnicode.length > 0;
+
       if (properties.hasIncludedToUnicodeMap) {
         if (!properties.composite && properties.hasEncoding) {
           properties.fallbackToUnicode = this._buildSimpleFontToUnicode(properties);
         }
+
         return Promise.resolve(properties.toUnicode);
       }
+
       if (!properties.composite) {
         return Promise.resolve(this._buildSimpleFontToUnicode(properties));
       }
-      if (properties.composite && (properties.cMap.builtInCMap && !(properties.cMap instanceof _cmap.IdentityCMap) || properties.cidSystemInfo.registry === 'Adobe' && (properties.cidSystemInfo.ordering === 'GB1' || properties.cidSystemInfo.ordering === 'CNS1' || properties.cidSystemInfo.ordering === 'Japan1' || properties.cidSystemInfo.ordering === 'Korea1'))) {
-        var registry = properties.cidSystemInfo.registry;
-        var ordering = properties.cidSystemInfo.ordering;
-        var ucs2CMapName = _primitives.Name.get(registry + '-' + ordering + '-UCS2');
+
+      if (properties.composite && (properties.cMap.builtInCMap && !(properties.cMap instanceof _cmap.IdentityCMap) || properties.cidSystemInfo.registry === "Adobe" && (properties.cidSystemInfo.ordering === "GB1" || properties.cidSystemInfo.ordering === "CNS1" || properties.cidSystemInfo.ordering === "Japan1" || properties.cidSystemInfo.ordering === "Korea1"))) {
+        const registry = properties.cidSystemInfo.registry;
+        const ordering = properties.cidSystemInfo.ordering;
+
+        const ucs2CMapName = _primitives.Name.get(registry + "-" + ordering + "-UCS2");
+
         return _cmap.CMapFactory.create({
           encoding: ucs2CMapName,
           fetchBuiltInCMap: this.fetchBuiltInCMap,
           useCMap: null
         }).then(function (ucs2CMap) {
-          var cMap = properties.cMap;
-          var toUnicode = [];
+          const cMap = properties.cMap;
+          const toUnicode = [];
           cMap.forEach(function (charcode, cid) {
             if (cid > 0xffff) {
-              throw new _util.FormatError('Max size of CID is 65,535');
+              throw new _util.FormatError("Max size of CID is 65,535");
             }
-            var ucs2 = ucs2CMap.lookup(cid);
+
+            const ucs2 = ucs2CMap.lookup(cid);
+
             if (ucs2) {
               toUnicode[charcode] = String.fromCharCode((ucs2.charCodeAt(0) << 8) + ucs2.charCodeAt(1));
             }
@@ -1777,11 +2308,13 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
           return new _fonts.ToUnicodeMap(toUnicode);
         });
       }
+
       return Promise.resolve(new _fonts.IdentityToUnicodeMap(properties.firstChar, properties.lastChar));
     },
 
     readToUnicode: function PartialEvaluator_readToUnicode(toUnicode) {
       var cmapObj = toUnicode;
+
       if ((0, _primitives.isName)(cmapObj)) {
         return _cmap.CMapFactory.create({
           encoding: cmapObj,
@@ -1789,8 +2322,9 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
           useCMap: null
         }).then(function (cmap) {
           if (cmap instanceof _cmap.IdentityCMap) {
-            return new _fonts.IdentityToUnicodeMap(0, 0xFFFF);
+            return new _fonts.IdentityToUnicodeMap(0, 0xffff);
           }
+
           return new _fonts.ToUnicodeMap(cmap.getMap());
         });
       } else if ((0, _primitives.isStream)(cmapObj)) {
@@ -1800,41 +2334,66 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
           useCMap: null
         }).then(function (cmap) {
           if (cmap instanceof _cmap.IdentityCMap) {
-            return new _fonts.IdentityToUnicodeMap(0, 0xFFFF);
+            return new _fonts.IdentityToUnicodeMap(0, 0xffff);
           }
+
           var map = new Array(cmap.length);
           cmap.forEach(function (charCode, token) {
             var str = [];
+
             for (var k = 0; k < token.length; k += 2) {
               var w1 = token.charCodeAt(k) << 8 | token.charCodeAt(k + 1);
-              if ((w1 & 0xF800) !== 0xD800) {
+
+              if ((w1 & 0xf800) !== 0xd800) {
                 str.push(w1);
                 continue;
               }
+
               k += 2;
               var w2 = token.charCodeAt(k) << 8 | token.charCodeAt(k + 1);
               str.push(((w1 & 0x3ff) << 10) + (w2 & 0x3ff) + 0x10000);
             }
-            map[charCode] = String.fromCharCode.apply(String, str);
+
+            map[charCode] = String.fromCodePoint.apply(String, str);
           });
           return new _fonts.ToUnicodeMap(map);
+        }, reason => {
+          if (reason instanceof _util.AbortException) {
+            return null;
+          }
+
+          if (this.options.ignoreErrors) {
+            this.handler.send("UnsupportedFeature", {
+              featureId: _util.UNSUPPORTED_FEATURES.font
+            });
+            (0, _util.warn)(`readToUnicode - ignoring ToUnicode data: "${reason}".`);
+            return null;
+          }
+
+          throw reason;
         });
       }
+
       return Promise.resolve(null);
     },
-    readCidToGidMap: function PartialEvaluator_readCidToGidMap(cidToGidStream) {
-      var glyphsData = cidToGidStream.getBytes();
+
+    readCidToGidMap(glyphsData, toUnicode) {
       var result = [];
+
       for (var j = 0, jj = glyphsData.length; j < jj; j++) {
         var glyphID = glyphsData[j++] << 8 | glyphsData[j];
-        if (glyphID === 0) {
+        const code = j >> 1;
+
+        if (glyphID === 0 && !toUnicode.has(code)) {
           continue;
         }
-        var code = j >> 1;
+
         result[code] = glyphID;
       }
+
       return result;
     },
+
     extractWidths: function PartialEvaluator_extractWidths(dict, descriptor, properties) {
       var xref = this.xref;
       var glyphsWidths = [];
@@ -1842,39 +2401,47 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
       var glyphsVMetrics = [];
       var defaultVMetrics;
       var i, ii, j, jj, start, code, widths;
+
       if (properties.composite) {
-        defaultWidth = dict.has('DW') ? dict.get('DW') : 1000;
-        widths = dict.get('W');
+        defaultWidth = dict.has("DW") ? dict.get("DW") : 1000;
+        widths = dict.get("W");
+
         if (widths) {
           for (i = 0, ii = widths.length; i < ii; i++) {
             start = xref.fetchIfRef(widths[i++]);
             code = xref.fetchIfRef(widths[i]);
+
             if (Array.isArray(code)) {
               for (j = 0, jj = code.length; j < jj; j++) {
                 glyphsWidths[start++] = xref.fetchIfRef(code[j]);
               }
             } else {
               var width = xref.fetchIfRef(widths[++i]);
+
               for (j = start; j <= code; j++) {
                 glyphsWidths[j] = width;
               }
             }
           }
         }
+
         if (properties.vertical) {
-          var vmetrics = dict.getArray('DW2') || [880, -1000];
+          var vmetrics = dict.getArray("DW2") || [880, -1000];
           defaultVMetrics = [vmetrics[1], defaultWidth * 0.5, vmetrics[0]];
-          vmetrics = dict.get('W2');
+          vmetrics = dict.get("W2");
+
           if (vmetrics) {
             for (i = 0, ii = vmetrics.length; i < ii; i++) {
               start = xref.fetchIfRef(vmetrics[i++]);
               code = xref.fetchIfRef(vmetrics[i]);
+
               if (Array.isArray(code)) {
                 for (j = 0, jj = code.length; j < jj; j++) {
                   glyphsVMetrics[start++] = [xref.fetchIfRef(code[j++]), xref.fetchIfRef(code[j++]), xref.fetchIfRef(code[j])];
                 }
               } else {
                 var vmetric = [xref.fetchIfRef(vmetrics[++i]), xref.fetchIfRef(vmetrics[++i]), xref.fetchIfRef(vmetrics[++i])];
+
                 for (j = start; j <= code; j++) {
                   glyphsVMetrics[j] = vmetric;
                 }
@@ -1884,15 +2451,19 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
         }
       } else {
         var firstChar = properties.firstChar;
-        widths = dict.get('Widths');
+        widths = dict.get("Widths");
+
         if (widths) {
           j = firstChar;
+
           for (i = 0, ii = widths.length; i < ii; i++) {
             glyphsWidths[j++] = xref.fetchIfRef(widths[i]);
           }
-          defaultWidth = parseFloat(descriptor.get('MissingWidth')) || 0;
+
+          defaultWidth = parseFloat(descriptor.get("MissingWidth")) || 0;
         } else {
-          var baseFontName = dict.get('BaseFont');
+          var baseFontName = dict.get("BaseFont");
+
           if ((0, _primitives.isName)(baseFontName)) {
             var metrics = this.getBaseFontMetrics(baseFontName.name);
             glyphsWidths = this.buildCharCodeToWidth(metrics.widths, properties);
@@ -1900,32 +2471,39 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
           }
         }
       }
+
       var isMonospace = true;
       var firstWidth = defaultWidth;
+
       for (var glyph in glyphsWidths) {
         var glyphWidth = glyphsWidths[glyph];
+
         if (!glyphWidth) {
           continue;
         }
+
         if (!firstWidth) {
           firstWidth = glyphWidth;
           continue;
         }
+
         if (firstWidth !== glyphWidth) {
           isMonospace = false;
           break;
         }
       }
+
       if (isMonospace) {
         properties.flags |= _fonts.FontFlags.FixedPitch;
       }
+
       properties.defaultWidth = defaultWidth;
       properties.widths = glyphsWidths;
       properties.defaultVMetrics = defaultVMetrics;
       properties.vmetrics = glyphsVMetrics;
     },
     isSerifFont: function PartialEvaluator_isSerifFont(baseFontName) {
-      var fontNameWoStyle = baseFontName.split('-')[0];
+      var fontNameWoStyle = baseFontName.split("-")[0];
       return fontNameWoStyle in (0, _standard_fonts.getSerifFonts)() || fontNameWoStyle.search(/serif/gi) !== -1;
     },
     getBaseFontMetrics: function PartialEvaluator_getBaseFontMetrics(name) {
@@ -1935,74 +2513,93 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
       var stdFontMap = (0, _standard_fonts.getStdFontMap)();
       var lookupName = stdFontMap[name] || name;
       var Metrics = (0, _metrics.getMetrics)();
+
       if (!(lookupName in Metrics)) {
         if (this.isSerifFont(name)) {
-          lookupName = 'Times-Roman';
+          lookupName = "Times-Roman";
         } else {
-          lookupName = 'Helvetica';
+          lookupName = "Helvetica";
         }
       }
+
       var glyphWidths = Metrics[lookupName];
+
       if ((0, _util.isNum)(glyphWidths)) {
         defaultWidth = glyphWidths;
         monospace = true;
       } else {
         widths = glyphWidths();
       }
+
       return {
-        defaultWidth: defaultWidth,
-        monospace: monospace,
-        widths: widths
+        defaultWidth,
+        monospace,
+        widths
       };
     },
     buildCharCodeToWidth: function PartialEvaluator_bulildCharCodeToWidth(widthsByGlyphName, properties) {
       var widths = Object.create(null);
       var differences = properties.differences;
       var encoding = properties.defaultEncoding;
+
       for (var charCode = 0; charCode < 256; charCode++) {
         if (charCode in differences && widthsByGlyphName[differences[charCode]]) {
           widths[charCode] = widthsByGlyphName[differences[charCode]];
           continue;
         }
+
         if (charCode in encoding && widthsByGlyphName[encoding[charCode]]) {
           widths[charCode] = widthsByGlyphName[encoding[charCode]];
           continue;
         }
       }
+
       return widths;
     },
     preEvaluateFont: function PartialEvaluator_preEvaluateFont(dict) {
       var baseDict = dict;
-      var type = dict.get('Subtype');
+      var type = dict.get("Subtype");
+
       if (!(0, _primitives.isName)(type)) {
-        throw new _util.FormatError('invalid font Subtype');
+        throw new _util.FormatError("invalid font Subtype");
       }
+
       var composite = false;
       var uint8array;
-      if (type.name === 'Type0') {
-        var df = dict.get('DescendantFonts');
+
+      if (type.name === "Type0") {
+        var df = dict.get("DescendantFonts");
+
         if (!df) {
-          throw new _util.FormatError('Descendant fonts are not specified');
+          throw new _util.FormatError("Descendant fonts are not specified");
         }
+
         dict = Array.isArray(df) ? this.xref.fetchIfRef(df[0]) : df;
-        type = dict.get('Subtype');
+        type = dict.get("Subtype");
+
         if (!(0, _primitives.isName)(type)) {
-          throw new _util.FormatError('invalid font Subtype');
+          throw new _util.FormatError("invalid font Subtype");
         }
+
         composite = true;
       }
-      var descriptor = dict.get('FontDescriptor');
+
+      var descriptor = dict.get("FontDescriptor");
+
       if (descriptor) {
         var hash = new _murmurhash.MurmurHash3_64();
-        var encoding = baseDict.getRaw('Encoding');
+        var encoding = baseDict.getRaw("Encoding");
+
         if ((0, _primitives.isName)(encoding)) {
           hash.update(encoding.name);
         } else if ((0, _primitives.isRef)(encoding)) {
           hash.update(encoding.toString());
         } else if ((0, _primitives.isDict)(encoding)) {
           var keys = encoding.getKeys();
+
           for (var i = 0, ii = keys.length; i < ii; i++) {
             var entry = encoding.getRaw(keys[i]);
+
             if ((0, _primitives.isName)(entry)) {
               hash.update(entry.name);
             } else if ((0, _primitives.isRef)(entry)) {
@@ -2010,19 +2607,27 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
             } else if (Array.isArray(entry)) {
               var diffLength = entry.length,
                   diffBuf = new Array(diffLength);
+
               for (var j = 0; j < diffLength; j++) {
                 var diffEntry = entry[j];
+
                 if ((0, _primitives.isName)(diffEntry)) {
                   diffBuf[j] = diffEntry.name;
                 } else if ((0, _util.isNum)(diffEntry) || (0, _primitives.isRef)(diffEntry)) {
                   diffBuf[j] = diffEntry.toString();
                 }
               }
+
               hash.update(diffBuf.join());
             }
           }
         }
-        var toUnicode = dict.get('ToUnicode') || baseDict.get('ToUnicode');
+
+        const firstChar = dict.get("FirstChar") || 0;
+        const lastChar = dict.get("LastChar") || (composite ? 0xffff : 0xff);
+        hash.update(`${firstChar}-${lastChar}`);
+        var toUnicode = dict.get("ToUnicode") || baseDict.get("ToUnicode");
+
         if ((0, _primitives.isStream)(toUnicode)) {
           var stream = toUnicode.str || toUnicode;
           uint8array = stream.buffer ? new Uint8Array(stream.buffer.buffer, 0, stream.bufferLength) : new Uint8Array(stream.bytes.buffer, stream.start, stream.end - stream.start);
@@ -2030,126 +2635,159 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
         } else if ((0, _primitives.isName)(toUnicode)) {
           hash.update(toUnicode.name);
         }
-        var widths = dict.get('Widths') || baseDict.get('Widths');
+
+        var widths = dict.get("Widths") || baseDict.get("Widths");
+
         if (widths) {
           uint8array = new Uint8Array(new Uint32Array(widths).buffer);
           hash.update(uint8array);
         }
       }
+
       return {
-        descriptor: descriptor,
-        dict: dict,
-        baseDict: baseDict,
-        composite: composite,
+        descriptor,
+        dict,
+        baseDict,
+        composite,
         type: type.name,
-        hash: hash ? hash.hexdigest() : ''
+        hash: hash ? hash.hexdigest() : ""
       };
     },
     translateFont: function PartialEvaluator_translateFont(preEvaluatedFont) {
-      var _this11 = this;
-
       var baseDict = preEvaluatedFont.baseDict;
       var dict = preEvaluatedFont.dict;
       var composite = preEvaluatedFont.composite;
       var descriptor = preEvaluatedFont.descriptor;
       var type = preEvaluatedFont.type;
-      var maxCharIndex = composite ? 0xFFFF : 0xFF;
+      var maxCharIndex = composite ? 0xffff : 0xff;
       var properties;
+      const firstChar = dict.get("FirstChar") || 0;
+      const lastChar = dict.get("LastChar") || maxCharIndex;
+
       if (!descriptor) {
-        if (type === 'Type3') {
+        if (type === "Type3") {
           descriptor = new _primitives.Dict(null);
-          descriptor.set('FontName', _primitives.Name.get(type));
-          descriptor.set('FontBBox', dict.getArray('FontBBox'));
+          descriptor.set("FontName", _primitives.Name.get(type));
+          descriptor.set("FontBBox", dict.getArray("FontBBox") || [0, 0, 0, 0]);
         } else {
-          var baseFontName = dict.get('BaseFont');
+          var baseFontName = dict.get("BaseFont");
+
           if (!(0, _primitives.isName)(baseFontName)) {
-            throw new _util.FormatError('Base font is not specified');
+            throw new _util.FormatError("Base font is not specified");
           }
-          baseFontName = baseFontName.name.replace(/[,_]/g, '-');
+
+          baseFontName = baseFontName.name.replace(/[,_]/g, "-");
           var metrics = this.getBaseFontMetrics(baseFontName);
-          var fontNameWoStyle = baseFontName.split('-')[0];
+          var fontNameWoStyle = baseFontName.split("-")[0];
           var flags = (this.isSerifFont(fontNameWoStyle) ? _fonts.FontFlags.Serif : 0) | (metrics.monospace ? _fonts.FontFlags.FixedPitch : 0) | ((0, _standard_fonts.getSymbolsFonts)()[fontNameWoStyle] ? _fonts.FontFlags.Symbolic : _fonts.FontFlags.Nonsymbolic);
           properties = {
-            type: type,
+            type,
             name: baseFontName,
             widths: metrics.widths,
             defaultWidth: metrics.defaultWidth,
-            flags: flags,
-            firstChar: 0,
-            lastChar: maxCharIndex
+            flags,
+            firstChar,
+            lastChar
           };
-          return this.extractDataStructures(dict, dict, properties).then(function (properties) {
-            properties.widths = _this11.buildCharCodeToWidth(metrics.widths, properties);
+          const widths = dict.get("Widths");
+          return this.extractDataStructures(dict, dict, properties).then(properties => {
+            if (widths) {
+              const glyphWidths = [];
+              let j = firstChar;
+
+              for (let i = 0, ii = widths.length; i < ii; i++) {
+                glyphWidths[j++] = this.xref.fetchIfRef(widths[i]);
+              }
+
+              properties.widths = glyphWidths;
+            } else {
+              properties.widths = this.buildCharCodeToWidth(metrics.widths, properties);
+            }
+
             return new _fonts.Font(baseFontName, null, properties);
           });
         }
       }
-      var firstChar = dict.get('FirstChar') || 0;
-      var lastChar = dict.get('LastChar') || maxCharIndex;
-      var fontName = descriptor.get('FontName');
-      var baseFont = dict.get('BaseFont');
+
+      var fontName = descriptor.get("FontName");
+      var baseFont = dict.get("BaseFont");
+
       if ((0, _util.isString)(fontName)) {
         fontName = _primitives.Name.get(fontName);
       }
+
       if ((0, _util.isString)(baseFont)) {
         baseFont = _primitives.Name.get(baseFont);
       }
-      if (type !== 'Type3') {
+
+      if (type !== "Type3") {
         var fontNameStr = fontName && fontName.name;
         var baseFontStr = baseFont && baseFont.name;
+
         if (fontNameStr !== baseFontStr) {
-          (0, _util.info)('The FontDescriptor\'s FontName is "' + fontNameStr + '" but should be the same as the Font\'s BaseFont "' + baseFontStr + '"');
-          if (fontNameStr && baseFontStr && baseFontStr.indexOf(fontNameStr) === 0) {
+          (0, _util.info)(`The FontDescriptor\'s FontName is "${fontNameStr}" but ` + `should be the same as the Font\'s BaseFont "${baseFontStr}".`);
+
+          if (fontNameStr && baseFontStr && baseFontStr.startsWith(fontNameStr)) {
             fontName = baseFont;
           }
         }
       }
+
       fontName = fontName || baseFont;
+
       if (!(0, _primitives.isName)(fontName)) {
-        throw new _util.FormatError('invalid font name');
+        throw new _util.FormatError("invalid font name");
       }
-      var fontFile = descriptor.get('FontFile', 'FontFile2', 'FontFile3');
+
+      var fontFile = descriptor.get("FontFile", "FontFile2", "FontFile3");
+
       if (fontFile) {
         if (fontFile.dict) {
-          var subtype = fontFile.dict.get('Subtype');
+          var subtype = fontFile.dict.get("Subtype");
+
           if (subtype) {
             subtype = subtype.name;
           }
-          var length1 = fontFile.dict.get('Length1');
-          var length2 = fontFile.dict.get('Length2');
-          var length3 = fontFile.dict.get('Length3');
+
+          var length1 = fontFile.dict.get("Length1");
+          var length2 = fontFile.dict.get("Length2");
+          var length3 = fontFile.dict.get("Length3");
         }
       }
+
       properties = {
-        type: type,
+        type,
         name: fontName.name,
-        subtype: subtype,
+        subtype,
         file: fontFile,
-        length1: length1,
-        length2: length2,
-        length3: length3,
+        length1,
+        length2,
+        length3,
         loadedName: baseDict.loadedName,
-        composite: composite,
+        composite,
         wideChars: composite,
         fixedPitch: false,
-        fontMatrix: dict.getArray('FontMatrix') || _util.FONT_IDENTITY_MATRIX,
+        fontMatrix: dict.getArray("FontMatrix") || _util.FONT_IDENTITY_MATRIX,
         firstChar: firstChar || 0,
         lastChar: lastChar || maxCharIndex,
-        bbox: descriptor.getArray('FontBBox'),
-        ascent: descriptor.get('Ascent'),
-        descent: descriptor.get('Descent'),
-        xHeight: descriptor.get('XHeight'),
-        capHeight: descriptor.get('CapHeight'),
-        flags: descriptor.get('Flags'),
-        italicAngle: descriptor.get('ItalicAngle'),
+        bbox: descriptor.getArray("FontBBox"),
+        ascent: descriptor.get("Ascent"),
+        descent: descriptor.get("Descent"),
+        xHeight: descriptor.get("XHeight"),
+        capHeight: descriptor.get("CapHeight"),
+        flags: descriptor.get("Flags"),
+        italicAngle: descriptor.get("ItalicAngle"),
         isType3Font: false
       };
       var cMapPromise;
+
       if (composite) {
-        var cidEncoding = baseDict.get('Encoding');
+        var cidEncoding = baseDict.get("Encoding");
+
         if ((0, _primitives.isName)(cidEncoding)) {
           properties.cidEncoding = cidEncoding.name;
         }
+
         cMapPromise = _cmap.CMapFactory.create({
           encoding: cidEncoding,
           fetchBuiltInCMap: this.fetchBuiltInCMap,
@@ -2161,19 +2799,58 @@ var PartialEvaluator = function PartialEvaluatorClosure() {
       } else {
         cMapPromise = Promise.resolve(undefined);
       }
-      return cMapPromise.then(function () {
-        return _this11.extractDataStructures(dict, baseDict, properties);
-      }).then(function (properties) {
-        _this11.extractWidths(dict, descriptor, properties);
-        if (type === 'Type3') {
+
+      return cMapPromise.then(() => {
+        return this.extractDataStructures(dict, baseDict, properties);
+      }).then(properties => {
+        this.extractWidths(dict, descriptor, properties);
+
+        if (type === "Type3") {
           properties.isType3Font = true;
         }
+
         return new _fonts.Font(fontName.name, fontFile, properties);
       });
     }
   };
+
+  PartialEvaluator.buildFontPaths = function (font, glyphs, handler) {
+    function buildPath(fontChar) {
+      if (font.renderer.hasBuiltPath(fontChar)) {
+        return;
+      }
+
+      handler.send("commonobj", [`${font.loadedName}_path_${fontChar}`, "FontPath", font.renderer.getPathJs(fontChar)]);
+    }
+
+    for (const glyph of glyphs) {
+      buildPath(glyph.fontChar);
+      const accent = glyph.accent;
+
+      if (accent && accent.fontChar) {
+        buildPath(accent.fontChar);
+      }
+    }
+  };
+
+  PartialEvaluator.getFallbackFontDict = function () {
+    if (this._fallbackFontDict) {
+      return this._fallbackFontDict;
+    }
+
+    const dict = new _primitives.Dict();
+    dict.set("BaseFont", _primitives.Name.get("PDFJS-FallbackFont"));
+    dict.set("Type", _primitives.Name.get("FallbackType"));
+    dict.set("Subtype", _primitives.Name.get("FallbackType"));
+    dict.set("Encoding", _primitives.Name.get("WinAnsiEncoding"));
+    return this._fallbackFontDict = dict;
+  };
+
   return PartialEvaluator;
 }();
+
+exports.PartialEvaluator = PartialEvaluator;
+
 var TranslatedFont = function TranslatedFontClosure() {
   function TranslatedFont(loadedName, font, dict) {
     this.loadedName = loadedName;
@@ -2182,87 +2859,108 @@ var TranslatedFont = function TranslatedFontClosure() {
     this.type3Loaded = null;
     this.sent = false;
   }
+
   TranslatedFont.prototype = {
-    send: function send(handler) {
+    send(handler) {
       if (this.sent) {
         return;
       }
-      var fontData = this.font.exportData();
-      handler.send('commonobj', [this.loadedName, 'Font', fontData]);
+
       this.sent = true;
+      handler.send("commonobj", [this.loadedName, "Font", this.font.exportData()]);
+    },
+
+    fallback(handler) {
+      if (!this.font.data) {
+        return;
+      }
+
+      this.font.disableFontFace = true;
+      const glyphs = this.font.glyphCacheValues;
+      PartialEvaluator.buildFontPaths(this.font, glyphs, handler);
     },
-    loadType3Data: function loadType3Data(evaluator, resources, parentOperatorList, task) {
+
+    loadType3Data(evaluator, resources, parentOperatorList, task) {
       if (!this.font.isType3Font) {
-        throw new Error('Must be a Type3 font.');
+        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 charProcs = this.dict.get("CharProcs");
+      var fontResources = this.dict.get("Resources") || resources;
       var charProcKeys = charProcs.getKeys();
       var charProcOperatorList = Object.create(null);
 
-      var _loop2 = function _loop2() {
-        var key = charProcKeys[i];
+      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: task,
+            task,
             resources: fontResources,
-            operatorList: operatorList
+            operatorList
           }).then(function () {
             charProcOperatorList[key] = operatorList.getIR();
             parentOperatorList.addDependencies(operatorList.dependencies);
           }).catch(function (reason) {
-            (0, _util.warn)('Type3 font resource "' + key + '" is not available.');
+            (0, _util.warn)(`Type3 font resource "${key}" is not available.`);
             var operatorList = new _operator_list.OperatorList();
             charProcOperatorList[key] = operatorList.getIR();
           });
         });
-      };
-
-      for (var i = 0, n = charProcKeys.length; i < n; ++i) {
-        _loop2();
       }
+
       this.type3Loaded = loadCharProcsPromise.then(function () {
         translatedFont.charProcOperatorList = charProcOperatorList;
       });
       return this.type3Loaded;
     }
+
   };
   return TranslatedFont;
 }();
+
 var StateManager = function StateManagerClosure() {
   function StateManager(initialState) {
     this.state = initialState;
     this.stateStack = [];
   }
+
   StateManager.prototype = {
-    save: function save() {
+    save() {
       var old = this.state;
       this.stateStack.push(this.state);
       this.state = old.clone();
     },
-    restore: function restore() {
+
+    restore() {
       var prev = this.stateStack.pop();
+
       if (prev) {
         this.state = prev;
       }
     },
-    transform: function transform(args) {
+
+    transform(args) {
       this.state.ctm = _util.Util.transform(this.state.ctm, args);
     }
+
   };
   return StateManager;
 }();
+
 var TextState = function TextStateClosure() {
   function TextState() {
     this.ctm = new Float32Array(_util.IDENTITY_MATRIX);
@@ -2278,6 +2976,7 @@ var TextState = function TextStateClosure() {
     this.textHScale = 1;
     this.textRise = 0;
   }
+
   TextState.prototype = {
     setTextMatrix: function TextState_setTextMatrix(a, b, c, d, e, f) {
       var m = this.textMatrix;
@@ -2309,21 +3008,28 @@ var TextState = function TextStateClosure() {
     },
     calcTextLineMatrixAdvance: function TextState_calcTextLineMatrixAdvance(a, b, c, d, e, f) {
       var font = this.font;
+
       if (!font) {
         return null;
       }
+
       var m = this.textLineMatrix;
+
       if (!(a === m[0] && b === m[1] && c === m[2] && d === m[3])) {
         return null;
       }
+
       var txDiff = e - m[4],
           tyDiff = f - m[5];
+
       if (font.vertical && txDiff !== 0 || !font.vertical && tyDiff !== 0) {
         return null;
       }
+
       var tx,
           ty,
           denominator = a * d - b * c;
+
       if (font.vertical) {
         tx = -tyDiff * c / denominator;
         ty = tyDiff * a / denominator;
@@ -2331,6 +3037,7 @@ var TextState = function TextStateClosure() {
         tx = txDiff * d / denominator;
         ty = -txDiff * b / denominator;
       }
+
       return {
         width: tx,
         height: ty,
@@ -2355,6 +3062,7 @@ var TextState = function TextStateClosure() {
   };
   return TextState;
 }();
+
 var EvalState = function EvalStateClosure() {
   function EvalState() {
     this.ctm = new Float32Array(_util.IDENTITY_MATRIX);
@@ -2363,6 +3071,7 @@ var EvalState = function EvalStateClosure() {
     this.fillColorSpace = _colorspace.ColorSpace.singletons.gray;
     this.strokeColorSpace = _colorspace.ColorSpace.singletons.gray;
   }
+
   EvalState.prototype = {
     clone: function CanvasExtraState_clone() {
       return Object.create(this);
@@ -2370,234 +3079,235 @@ var EvalState = function EvalStateClosure() {
   };
   return EvalState;
 }();
+
 var EvaluatorPreprocessor = function EvaluatorPreprocessorClosure() {
-  var getOPMap = (0, _util.getLookupTableFactory)(function (t) {
-    t['w'] = {
+  var getOPMap = (0, _core_utils.getLookupTableFactory)(function (t) {
+    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
     };
-    t['f*'] = {
+    t["f*"] = {
       id: _util.OPS.eoFill,
       numArgs: 0,
       variableArgs: false
     };
-    t['B'] = {
+    t["B"] = {
       id: _util.OPS.fillStroke,
       numArgs: 0,
       variableArgs: false
     };
-    t['B*'] = {
+    t["B*"] = {
       id: _util.OPS.eoFillStroke,
       numArgs: 0,
       variableArgs: false
     };
-    t['b'] = {
+    t["b"] = {
       id: _util.OPS.closeFillStroke,
       numArgs: 0,
       variableArgs: false
     };
-    t['b*'] = {
+    t["b*"] = {
       id: _util.OPS.closeEOFillStroke,
       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
     };
-    t['W*'] = {
+    t["W*"] = {
       id: _util.OPS.eoClip,
       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
     };
-    t['T*'] = {
+    t["T*"] = {
       id: _util.OPS.nextLine,
       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
     };
-    t['\''] = {
+    t["'"] = {
       id: _util.OPS.nextLineShowText,
       numArgs: 1,
       variableArgs: false
@@ -2607,217 +3317,241 @@ 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;
   });
-  var MAX_INVALID_PATH_OPS = 20;
+  const MAX_INVALID_PATH_OPS = 20;
+
   function EvaluatorPreprocessor(stream, xref, stateManager) {
     this.opMap = getOPMap();
-    this.parser = new _parser.Parser(new _parser.Lexer(stream, this.opMap), false, xref);
+    this.parser = new _parser.Parser({
+      lexer: new _parser.Lexer(stream, this.opMap),
+      xref
+    });
     this.stateManager = stateManager;
     this.nonProcessedArgs = [];
     this._numInvalidPathOPS = 0;
   }
+
   EvaluatorPreprocessor.prototype = {
     get savedStatesDepth() {
       return this.stateManager.stateStack.length;
     },
+
     read: function EvaluatorPreprocessor_read(operation) {
       var args = operation.args;
+
       while (true) {
         var obj = this.parser.getObj();
-        if ((0, _primitives.isCmd)(obj)) {
+
+        if (obj instanceof _primitives.Cmd) {
           var cmd = obj.cmd;
           var opSpec = this.opMap[cmd];
+
           if (!opSpec) {
-            (0, _util.warn)('Unknown command "' + cmd + '".');
+            (0, _util.warn)(`Unknown command "${cmd}".`);
             continue;
           }
+
           var fn = opSpec.id;
           var numArgs = opSpec.numArgs;
           var argsLength = args !== null ? args.length : 0;
+
           if (!opSpec.variableArgs) {
             if (argsLength !== numArgs) {
               var nonProcessedArgs = this.nonProcessedArgs;
+
               while (argsLength > numArgs) {
                 nonProcessedArgs.push(args.shift());
                 argsLength--;
               }
+
               while (argsLength < numArgs && nonProcessedArgs.length !== 0) {
                 if (args === null) {
                   args = [];
                 }
+
                 args.unshift(nonProcessedArgs.pop());
                 argsLength++;
               }
             }
+
             if (argsLength < numArgs) {
-              var partialMsg = 'command ' + cmd + ': expected ' + numArgs + ' args, ' + ('but received ' + argsLength + ' args.');
+              const partialMsg = `command ${cmd}: expected ${numArgs} args, ` + `but received ${argsLength} args.`;
+
               if (fn >= _util.OPS.moveTo && fn <= _util.OPS.endPath && ++this._numInvalidPathOPS > MAX_INVALID_PATH_OPS) {
-                throw new _util.FormatError('Invalid ' + partialMsg);
+                throw new _util.FormatError(`Invalid ${partialMsg}`);
               }
-              (0, _util.warn)('Skipping ' + partialMsg);
+
+              (0, _util.warn)(`Skipping ${partialMsg}`);
+
               if (args !== null) {
                 args.length = 0;
               }
+
               continue;
             }
           } else if (argsLength > numArgs) {
-            (0, _util.info)('Command ' + cmd + ': expected [0, ' + numArgs + '] args, ' + ('but received ' + argsLength + ' args.'));
+            (0, _util.info)(`Command ${cmd}: expected [0, ${numArgs}] args, ` + `but received ${argsLength} args.`);
           }
+
           this.preprocessCommand(fn, args);
           operation.fn = fn;
           operation.args = args;
           return true;
         }
-        if ((0, _primitives.isEOF)(obj)) {
+
+        if (obj === _primitives.EOF) {
           return false;
         }
+
         if (obj !== null) {
           if (args === null) {
             args = [];
           }
+
           args.push(obj);
+
           if (args.length > 33) {
-            throw new _util.FormatError('Too many arguments');
+            throw new _util.FormatError("Too many arguments");
           }
         }
       }
@@ -2827,9 +3561,11 @@ var EvaluatorPreprocessor = function EvaluatorPreprocessorClosure() {
         case _util.OPS.save:
           this.stateManager.save();
           break;
+
         case _util.OPS.restore:
           this.stateManager.restore();
           break;
+
         case _util.OPS.transform:
           this.stateManager.transform(args);
           break;
@@ -2837,5 +3573,4 @@ var EvaluatorPreprocessor = function EvaluatorPreprocessorClosure() {
     }
   };
   return EvaluatorPreprocessor;
-}();
-exports.PartialEvaluator = PartialEvaluator;
+}();