pdfjs-dist 2.1.266 → 2.5.207

package/lib/core/obj.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.
@@ -26,1018 +26,1105 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.FileSpec = exports.XRef = exports.ObjectLoader = exports.Catalog = void 0;
 
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _util = require("../shared/util.js");
 
-var _util = require("../shared/util");
+var _primitives = require("./primitives.js");
 
-var _primitives = require("./primitives");
+var _parser = require("./parser.js");
 
-var _parser = require("./parser");
+var _core_utils = require("./core_utils.js");
 
-var _chunked_stream = require("./chunked_stream");
+var _crypto = require("./crypto.js");
 
-var _crypto = require("./crypto");
+var _colorspace = require("./colorspace.js");
 
-var _colorspace = require("./colorspace");
+var _image_utils = require("./image_utils.js");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function fetchDestination(dest) {
+  return (0, _primitives.isDict)(dest) ? dest.get("D") : dest;
+}
 
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+class Catalog {
+  constructor(pdfManager, xref) {
+    this.pdfManager = pdfManager;
+    this.xref = xref;
+    this.catDict = xref.getCatalogObj();
 
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+    if (!(0, _primitives.isDict)(this.catDict)) {
+      throw new _util.FormatError("Catalog object is not a dictionary.");
+    }
 
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+    this.fontCache = new _primitives.RefSetCache();
+    this.builtInCMapCache = new Map();
+    this.globalImageCache = new _image_utils.GlobalImageCache();
+    this.pageKidsCountCache = new _primitives.RefSetCache();
+  }
 
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+  get metadata() {
+    const streamRef = this.catDict.getRaw("Metadata");
 
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+    if (!(0, _primitives.isRef)(streamRef)) {
+      return (0, _util.shadow)(this, "metadata", null);
+    }
 
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
+    const suppressEncryption = !(this.xref.encrypt && this.xref.encrypt.encryptMetadata);
+    const stream = this.xref.fetch(streamRef, suppressEncryption);
+    let metadata;
 
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
+    if (stream && (0, _primitives.isDict)(stream.dict)) {
+      const type = stream.dict.get("Type");
+      const subtype = stream.dict.get("Subtype");
 
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
+      if ((0, _primitives.isName)(type, "Metadata") && (0, _primitives.isName)(subtype, "XML")) {
+        try {
+          metadata = (0, _util.stringToUTF8String)((0, _util.bytesToString)(stream.getBytes()));
+        } catch (e) {
+          if (e instanceof _core_utils.MissingDataException) {
+            throw e;
+          }
 
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
+          (0, _util.info)("Skipping invalid metadata.");
+        }
+      }
+    }
 
-function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
+    return (0, _util.shadow)(this, "metadata", metadata);
+  }
 
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
+  get toplevelPagesDict() {
+    const pagesObj = this.catDict.get("Pages");
 
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+    if (!(0, _primitives.isDict)(pagesObj)) {
+      throw new _util.FormatError("Invalid top-level pages dictionary.");
+    }
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+    return (0, _util.shadow)(this, "toplevelPagesDict", pagesObj);
+  }
 
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+  get documentOutline() {
+    let obj = null;
 
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+    try {
+      obj = this._readDocumentOutline();
+    } catch (ex) {
+      if (ex instanceof _core_utils.MissingDataException) {
+        throw ex;
+      }
 
-function fetchDestination(dest) {
-  return (0, _primitives.isDict)(dest) ? dest.get('D') : dest;
-}
+      (0, _util.warn)("Unable to read document outline.");
+    }
 
-var Catalog =
-/*#__PURE__*/
-function () {
-  function Catalog(pdfManager, xref) {
-    _classCallCheck(this, Catalog);
+    return (0, _util.shadow)(this, "documentOutline", obj);
+  }
 
-    this.pdfManager = pdfManager;
-    this.xref = xref;
-    this.catDict = xref.getCatalogObj();
+  _readDocumentOutline() {
+    let obj = this.catDict.get("Outlines");
 
-    if (!(0, _primitives.isDict)(this.catDict)) {
-      throw new _util.FormatError('Catalog object is not a dictionary.');
+    if (!(0, _primitives.isDict)(obj)) {
+      return null;
     }
 
-    this.fontCache = new _primitives.RefSetCache();
-    this.builtInCMapCache = new Map();
-    this.pageKidsCountCache = new _primitives.RefSetCache();
-  }
+    obj = obj.getRaw("First");
 
-  _createClass(Catalog, [{
-    key: "_readDocumentOutline",
-    value: function _readDocumentOutline() {
-      var obj = this.catDict.get('Outlines');
+    if (!(0, _primitives.isRef)(obj)) {
+      return null;
+    }
 
-      if (!(0, _primitives.isDict)(obj)) {
-        return null;
-      }
+    const root = {
+      items: []
+    };
+    const queue = [{
+      obj,
+      parent: root
+    }];
+    const processed = new _primitives.RefSet();
+    processed.put(obj);
+    const xref = this.xref,
+          blackColor = new Uint8ClampedArray(3);
 
-      obj = obj.getRaw('First');
+    while (queue.length > 0) {
+      const i = queue.shift();
+      const outlineDict = xref.fetchIfRef(i.obj);
 
-      if (!(0, _primitives.isRef)(obj)) {
-        return null;
+      if (outlineDict === null) {
+        continue;
+      }
+
+      if (!outlineDict.has("Title")) {
+        throw new _util.FormatError("Invalid outline item encountered.");
       }
 
-      var root = {
+      const data = {
+        url: null,
+        dest: null
+      };
+      Catalog.parseDestDictionary({
+        destDict: outlineDict,
+        resultObj: data,
+        docBaseUrl: this.pdfManager.docBaseUrl
+      });
+      const title = outlineDict.get("Title");
+      const flags = outlineDict.get("F") || 0;
+      const color = outlineDict.getArray("C");
+      const count = outlineDict.get("Count");
+      let rgbColor = blackColor;
+
+      if (Array.isArray(color) && color.length === 3 && (color[0] !== 0 || color[1] !== 0 || color[2] !== 0)) {
+        rgbColor = _colorspace.ColorSpace.singletons.rgb.getRgb(color, 0);
+      }
+
+      const outlineItem = {
+        dest: data.dest,
+        url: data.url,
+        unsafeUrl: data.unsafeUrl,
+        newWindow: data.newWindow,
+        title: (0, _util.stringToPDFString)(title),
+        color: rgbColor,
+        count: Number.isInteger(count) ? count : undefined,
+        bold: !!(flags & 2),
+        italic: !!(flags & 1),
         items: []
       };
-      var queue = [{
-        obj: obj,
-        parent: root
-      }];
-      var processed = new _primitives.RefSet();
-      processed.put(obj);
-      var xref = this.xref,
-          blackColor = new Uint8ClampedArray(3);
+      i.parent.items.push(outlineItem);
+      obj = outlineDict.getRaw("First");
 
-      while (queue.length > 0) {
-        var i = queue.shift();
-        var outlineDict = xref.fetchIfRef(i.obj);
-
-        if (outlineDict === null) {
-          continue;
-        }
+      if ((0, _primitives.isRef)(obj) && !processed.has(obj)) {
+        queue.push({
+          obj,
+          parent: outlineItem
+        });
+        processed.put(obj);
+      }
 
-        if (!outlineDict.has('Title')) {
-          throw new _util.FormatError('Invalid outline item encountered.');
-        }
+      obj = outlineDict.getRaw("Next");
 
-        var data = {
-          url: null,
-          dest: null
-        };
-        Catalog.parseDestDictionary({
-          destDict: outlineDict,
-          resultObj: data,
-          docBaseUrl: this.pdfManager.docBaseUrl
+      if ((0, _primitives.isRef)(obj) && !processed.has(obj)) {
+        queue.push({
+          obj,
+          parent: i.parent
         });
-        var title = outlineDict.get('Title');
-        var flags = outlineDict.get('F') || 0;
-        var color = outlineDict.getArray('C');
-        var rgbColor = blackColor;
-
-        if (Array.isArray(color) && color.length === 3 && (color[0] !== 0 || color[1] !== 0 || color[2] !== 0)) {
-          rgbColor = _colorspace.ColorSpace.singletons.rgb.getRgb(color, 0);
-        }
-
-        var outlineItem = {
-          dest: data.dest,
-          url: data.url,
-          unsafeUrl: data.unsafeUrl,
-          newWindow: data.newWindow,
-          title: (0, _util.stringToPDFString)(title),
-          color: rgbColor,
-          count: outlineDict.get('Count'),
-          bold: !!(flags & 2),
-          italic: !!(flags & 1),
-          items: []
-        };
-        i.parent.items.push(outlineItem);
-        obj = outlineDict.getRaw('First');
+        processed.put(obj);
+      }
+    }
 
-        if ((0, _primitives.isRef)(obj) && !processed.has(obj)) {
-          queue.push({
-            obj: obj,
-            parent: outlineItem
-          });
-          processed.put(obj);
-        }
+    return root.items.length > 0 ? root.items : null;
+  }
 
-        obj = outlineDict.getRaw('Next');
+  get permissions() {
+    let permissions = null;
 
-        if ((0, _primitives.isRef)(obj) && !processed.has(obj)) {
-          queue.push({
-            obj: obj,
-            parent: i.parent
-          });
-          processed.put(obj);
-        }
+    try {
+      permissions = this._readPermissions();
+    } catch (ex) {
+      if (ex instanceof _core_utils.MissingDataException) {
+        throw ex;
       }
 
-      return root.items.length > 0 ? root.items : null;
+      (0, _util.warn)("Unable to read permissions.");
     }
-  }, {
-    key: "_readPermissions",
-    value: function _readPermissions() {
-      var encrypt = this.xref.trailer.get('Encrypt');
 
-      if (!(0, _primitives.isDict)(encrypt)) {
-        return null;
-      }
+    return (0, _util.shadow)(this, "permissions", permissions);
+  }
 
-      var flags = encrypt.get('P');
+  _readPermissions() {
+    const encrypt = this.xref.trailer.get("Encrypt");
 
-      if (!(0, _util.isNum)(flags)) {
-        return null;
-      }
+    if (!(0, _primitives.isDict)(encrypt)) {
+      return null;
+    }
+
+    let flags = encrypt.get("P");
+
+    if (!(0, _util.isNum)(flags)) {
+      return null;
+    }
 
-      flags += Math.pow(2, 32);
-      var permissions = [];
+    flags += 2 ** 32;
+    const permissions = [];
 
-      for (var key in _util.PermissionFlag) {
-        var value = _util.PermissionFlag[key];
+    for (const key in _util.PermissionFlag) {
+      const value = _util.PermissionFlag[key];
 
-        if (flags & value) {
-          permissions.push(value);
-        }
+      if (flags & value) {
+        permissions.push(value);
       }
+    }
 
-      return permissions;
+    return permissions;
+  }
+
+  get numPages() {
+    const obj = this.toplevelPagesDict.get("Count");
+
+    if (!Number.isInteger(obj)) {
+      throw new _util.FormatError("Page count in top-level pages dictionary is not an integer.");
     }
-  }, {
-    key: "getDestination",
-    value: function getDestination(destinationId) {
-      var obj = this._readDests();
 
-      if (obj instanceof NameTree || obj instanceof _primitives.Dict) {
-        return fetchDestination(obj.get(destinationId) || null);
+    return (0, _util.shadow)(this, "numPages", obj);
+  }
+
+  get destinations() {
+    const obj = this._readDests(),
+          dests = Object.create(null);
+
+    if (obj instanceof NameTree) {
+      const names = obj.getAll();
+
+      for (const name in names) {
+        dests[name] = fetchDestination(names[name]);
       }
+    } else if (obj instanceof _primitives.Dict) {
+      obj.forEach(function (key, value) {
+        if (value) {
+          dests[key] = fetchDestination(value);
+        }
+      });
+    }
 
-      return null;
+    return (0, _util.shadow)(this, "destinations", dests);
+  }
+
+  getDestination(destinationId) {
+    const obj = this._readDests();
+
+    if (obj instanceof NameTree || obj instanceof _primitives.Dict) {
+      return fetchDestination(obj.get(destinationId) || null);
     }
-  }, {
-    key: "_readDests",
-    value: function _readDests() {
-      var obj = this.catDict.get('Names');
 
-      if (obj && obj.has('Dests')) {
-        return new NameTree(obj.getRaw('Dests'), this.xref);
-      } else if (this.catDict.has('Dests')) {
-        return this.catDict.get('Dests');
-      }
+    return null;
+  }
+
+  _readDests() {
+    const obj = this.catDict.get("Names");
+
+    if (obj && obj.has("Dests")) {
+      return new NameTree(obj.getRaw("Dests"), this.xref);
+    } else if (this.catDict.has("Dests")) {
+      return this.catDict.get("Dests");
     }
-  }, {
-    key: "_readPageLabels",
-    value: function _readPageLabels() {
-      var obj = this.catDict.getRaw('PageLabels');
 
-      if (!obj) {
-        return null;
+    return undefined;
+  }
+
+  get pageLabels() {
+    let obj = null;
+
+    try {
+      obj = this._readPageLabels();
+    } catch (ex) {
+      if (ex instanceof _core_utils.MissingDataException) {
+        throw ex;
       }
 
-      var pageLabels = new Array(this.numPages);
-      var style = null,
-          prefix = '';
-      var numberTree = new NumberTree(obj, this.xref);
-      var nums = numberTree.getAll();
-      var currentLabel = '',
-          currentIndex = 1;
+      (0, _util.warn)("Unable to read page labels.");
+    }
 
-      for (var i = 0, ii = this.numPages; i < ii; i++) {
-        if (i in nums) {
-          var labelDict = nums[i];
+    return (0, _util.shadow)(this, "pageLabels", obj);
+  }
 
-          if (!(0, _primitives.isDict)(labelDict)) {
-            throw new _util.FormatError('PageLabel is not a dictionary.');
-          }
+  _readPageLabels() {
+    const obj = this.catDict.getRaw("PageLabels");
 
-          if (labelDict.has('Type') && !(0, _primitives.isName)(labelDict.get('Type'), 'PageLabel')) {
-            throw new _util.FormatError('Invalid type in PageLabel dictionary.');
-          }
+    if (!obj) {
+      return null;
+    }
 
-          if (labelDict.has('S')) {
-            var s = labelDict.get('S');
+    const pageLabels = new Array(this.numPages);
+    let style = null,
+        prefix = "";
+    const numberTree = new NumberTree(obj, this.xref);
+    const nums = numberTree.getAll();
+    let currentLabel = "",
+        currentIndex = 1;
 
-            if (!(0, _primitives.isName)(s)) {
-              throw new _util.FormatError('Invalid style in PageLabel dictionary.');
-            }
+    for (let i = 0, ii = this.numPages; i < ii; i++) {
+      if (i in nums) {
+        const labelDict = nums[i];
 
-            style = s.name;
-          } else {
-            style = null;
+        if (!(0, _primitives.isDict)(labelDict)) {
+          throw new _util.FormatError("PageLabel is not a dictionary.");
+        }
+
+        if (labelDict.has("Type") && !(0, _primitives.isName)(labelDict.get("Type"), "PageLabel")) {
+          throw new _util.FormatError("Invalid type in PageLabel dictionary.");
+        }
+
+        if (labelDict.has("S")) {
+          const s = labelDict.get("S");
+
+          if (!(0, _primitives.isName)(s)) {
+            throw new _util.FormatError("Invalid style in PageLabel dictionary.");
           }
 
-          if (labelDict.has('P')) {
-            var p = labelDict.get('P');
+          style = s.name;
+        } else {
+          style = null;
+        }
 
-            if (!(0, _util.isString)(p)) {
-              throw new _util.FormatError('Invalid prefix in PageLabel dictionary.');
-            }
+        if (labelDict.has("P")) {
+          const p = labelDict.get("P");
 
-            prefix = (0, _util.stringToPDFString)(p);
-          } else {
-            prefix = '';
+          if (!(0, _util.isString)(p)) {
+            throw new _util.FormatError("Invalid prefix in PageLabel dictionary.");
           }
 
-          if (labelDict.has('St')) {
-            var st = labelDict.get('St');
+          prefix = (0, _util.stringToPDFString)(p);
+        } else {
+          prefix = "";
+        }
 
-            if (!(Number.isInteger(st) && st >= 1)) {
-              throw new _util.FormatError('Invalid start in PageLabel dictionary.');
-            }
+        if (labelDict.has("St")) {
+          const st = labelDict.get("St");
 
-            currentIndex = st;
-          } else {
-            currentIndex = 1;
+          if (!(Number.isInteger(st) && st >= 1)) {
+            throw new _util.FormatError("Invalid start in PageLabel dictionary.");
           }
+
+          currentIndex = st;
+        } else {
+          currentIndex = 1;
         }
+      }
 
-        switch (style) {
-          case 'D':
-            currentLabel = currentIndex;
-            break;
+      switch (style) {
+        case "D":
+          currentLabel = currentIndex;
+          break;
 
-          case 'R':
-          case 'r':
-            currentLabel = (0, _util.toRomanNumerals)(currentIndex, style === 'r');
-            break;
+        case "R":
+        case "r":
+          currentLabel = (0, _core_utils.toRomanNumerals)(currentIndex, style === "r");
+          break;
 
-          case 'A':
-          case 'a':
-            var LIMIT = 26;
-            var A_UPPER_CASE = 0x41,
+        case "A":
+        case "a":
+          const LIMIT = 26;
+          const A_UPPER_CASE = 0x41,
                 A_LOWER_CASE = 0x61;
-            var baseCharCode = style === 'a' ? A_LOWER_CASE : A_UPPER_CASE;
-            var letterIndex = currentIndex - 1;
-            var character = String.fromCharCode(baseCharCode + letterIndex % LIMIT);
-            var charBuf = [];
+          const baseCharCode = style === "a" ? A_LOWER_CASE : A_UPPER_CASE;
+          const letterIndex = currentIndex - 1;
+          const character = String.fromCharCode(baseCharCode + letterIndex % LIMIT);
+          const charBuf = [];
 
-            for (var j = 0, jj = letterIndex / LIMIT | 0; j <= jj; j++) {
-              charBuf.push(character);
-            }
-
-            currentLabel = charBuf.join('');
-            break;
+          for (let j = 0, jj = letterIndex / LIMIT | 0; j <= jj; j++) {
+            charBuf.push(character);
+          }
 
-          default:
-            if (style) {
-              throw new _util.FormatError("Invalid style \"".concat(style, "\" in PageLabel dictionary."));
-            }
+          currentLabel = charBuf.join("");
+          break;
 
-            currentLabel = '';
-        }
+        default:
+          if (style) {
+            throw new _util.FormatError(`Invalid style "${style}" in PageLabel dictionary.`);
+          }
 
-        pageLabels[i] = prefix + currentLabel;
-        currentIndex++;
+          currentLabel = "";
       }
 
-      return pageLabels;
+      pageLabels[i] = prefix + currentLabel;
+      currentIndex++;
     }
-  }, {
-    key: "fontFallback",
-    value: function fontFallback(id, handler) {
-      var promises = [];
-      this.fontCache.forEach(function (promise) {
-        promises.push(promise);
-      });
-      return Promise.all(promises).then(function (translatedFonts) {
-        var _iteratorNormalCompletion = true;
-        var _didIteratorError = false;
-        var _iteratorError = undefined;
-
-        try {
-          for (var _iterator = translatedFonts[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-            var translatedFont = _step.value;
 
-            if (translatedFont.loadedName === id) {
-              translatedFont.fallback(handler);
-              return;
-            }
-          }
-        } catch (err) {
-          _didIteratorError = true;
-          _iteratorError = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion && _iterator.return != null) {
-              _iterator.return();
-            }
-          } finally {
-            if (_didIteratorError) {
-              throw _iteratorError;
-            }
-          }
-        }
-      });
-    }
-  }, {
-    key: "cleanup",
-    value: function cleanup() {
-      var _this = this;
-
-      this.pageKidsCountCache.clear();
-      var promises = [];
-      this.fontCache.forEach(function (promise) {
-        promises.push(promise);
-      });
-      return Promise.all(promises).then(function (translatedFonts) {
-        for (var i = 0, ii = translatedFonts.length; i < ii; i++) {
-          var font = translatedFonts[i].dict;
-          delete font.translated;
-        }
+    return pageLabels;
+  }
 
-        _this.fontCache.clear();
+  get pageLayout() {
+    const obj = this.catDict.get("PageLayout");
+    let pageLayout = "";
 
-        _this.builtInCMapCache.clear();
-      });
+    if ((0, _primitives.isName)(obj)) {
+      switch (obj.name) {
+        case "SinglePage":
+        case "OneColumn":
+        case "TwoColumnLeft":
+        case "TwoColumnRight":
+        case "TwoPageLeft":
+        case "TwoPageRight":
+          pageLayout = obj.name;
+      }
     }
-  }, {
-    key: "getPageDict",
-    value: function getPageDict(pageIndex) {
-      var capability = (0, _util.createPromiseCapability)();
-      var nodesToVisit = [this.catDict.getRaw('Pages')];
-      var xref = this.xref,
-          pageKidsCountCache = this.pageKidsCountCache;
-      var count,
-          currentPageIndex = 0;
 
-      function next() {
-        var _loop = function _loop() {
-          var currentNode = nodesToVisit.pop();
+    return (0, _util.shadow)(this, "pageLayout", pageLayout);
+  }
 
-          if ((0, _primitives.isRef)(currentNode)) {
-            count = pageKidsCountCache.get(currentNode);
+  get pageMode() {
+    const obj = this.catDict.get("PageMode");
+    let pageMode = "UseNone";
 
-            if (count > 0 && currentPageIndex + count < pageIndex) {
-              currentPageIndex += count;
-              return "continue";
-            }
+    if ((0, _primitives.isName)(obj)) {
+      switch (obj.name) {
+        case "UseNone":
+        case "UseOutlines":
+        case "UseThumbs":
+        case "FullScreen":
+        case "UseOC":
+        case "UseAttachments":
+          pageMode = obj.name;
+      }
+    }
 
-            xref.fetchAsync(currentNode).then(function (obj) {
-              if ((0, _primitives.isDict)(obj, 'Page') || (0, _primitives.isDict)(obj) && !obj.has('Kids')) {
-                if (pageIndex === currentPageIndex) {
-                  if (currentNode && !pageKidsCountCache.has(currentNode)) {
-                    pageKidsCountCache.put(currentNode, 1);
-                  }
-
-                  capability.resolve([obj, currentNode]);
-                } else {
-                  currentPageIndex++;
-                  next();
-                }
+    return (0, _util.shadow)(this, "pageMode", pageMode);
+  }
 
-                return;
-              }
+  get viewerPreferences() {
+    const ViewerPreferencesValidators = {
+      HideToolbar: _util.isBool,
+      HideMenubar: _util.isBool,
+      HideWindowUI: _util.isBool,
+      FitWindow: _util.isBool,
+      CenterWindow: _util.isBool,
+      DisplayDocTitle: _util.isBool,
+      NonFullScreenPageMode: _primitives.isName,
+      Direction: _primitives.isName,
+      ViewArea: _primitives.isName,
+      ViewClip: _primitives.isName,
+      PrintArea: _primitives.isName,
+      PrintClip: _primitives.isName,
+      PrintScaling: _primitives.isName,
+      Duplex: _primitives.isName,
+      PickTrayByPDFSize: _util.isBool,
+      PrintPageRange: Array.isArray,
+      NumCopies: Number.isInteger
+    };
+    const obj = this.catDict.get("ViewerPreferences");
+    let prefs = null;
 
-              nodesToVisit.push(obj);
-              next();
-            }, capability.reject);
-            return {
-              v: void 0
-            };
-          }
+    if ((0, _primitives.isDict)(obj)) {
+      for (const key in ViewerPreferencesValidators) {
+        if (!obj.has(key)) {
+          continue;
+        }
 
-          if (!(0, _primitives.isDict)(currentNode)) {
-            capability.reject(new _util.FormatError('Page dictionary kid reference points to wrong type of object.'));
-            return {
-              v: void 0
-            };
-          }
+        const value = obj.get(key);
 
-          count = currentNode.get('Count');
+        if (!ViewerPreferencesValidators[key](value)) {
+          (0, _util.info)(`Bad value in ViewerPreferences for "${key}".`);
+          continue;
+        }
 
-          if (Number.isInteger(count) && count >= 0) {
-            var objId = currentNode.objId;
+        let prefValue;
 
-            if (objId && !pageKidsCountCache.has(objId)) {
-              pageKidsCountCache.put(objId, count);
-            }
+        switch (key) {
+          case "NonFullScreenPageMode":
+            switch (value.name) {
+              case "UseNone":
+              case "UseOutlines":
+              case "UseThumbs":
+              case "UseOC":
+                prefValue = value.name;
+                break;
 
-            if (currentPageIndex + count <= pageIndex) {
-              currentPageIndex += count;
-              return "continue";
+              default:
+                prefValue = "UseNone";
             }
-          }
 
-          var kids = currentNode.get('Kids');
+            break;
 
-          if (!Array.isArray(kids)) {
-            if ((0, _primitives.isName)(currentNode.get('Type'), 'Page') || !currentNode.has('Type') && currentNode.has('Contents')) {
-              if (currentPageIndex === pageIndex) {
-                capability.resolve([currentNode, null]);
-                return {
-                  v: void 0
-                };
-              }
+          case "Direction":
+            switch (value.name) {
+              case "L2R":
+              case "R2L":
+                prefValue = value.name;
+                break;
 
-              currentPageIndex++;
-              return "continue";
+              default:
+                prefValue = "L2R";
             }
 
-            capability.reject(new _util.FormatError('Page dictionary kids object is not an array.'));
-            return {
-              v: void 0
-            };
-          }
-
-          for (var last = kids.length - 1; last >= 0; last--) {
-            nodesToVisit.push(kids[last]);
-          }
-        };
+            break;
 
-        while (nodesToVisit.length) {
-          var _ret = _loop();
+          case "ViewArea":
+          case "ViewClip":
+          case "PrintArea":
+          case "PrintClip":
+            switch (value.name) {
+              case "MediaBox":
+              case "CropBox":
+              case "BleedBox":
+              case "TrimBox":
+              case "ArtBox":
+                prefValue = value.name;
+                break;
 
-          switch (_ret) {
-            case "continue":
-              continue;
+              default:
+                prefValue = "CropBox";
+            }
 
-            default:
-              if (_typeof(_ret) === "object") return _ret.v;
-          }
-        }
+            break;
 
-        capability.reject(new Error("Page index ".concat(pageIndex, " not found.")));
-      }
+          case "PrintScaling":
+            switch (value.name) {
+              case "None":
+              case "AppDefault":
+                prefValue = value.name;
+                break;
 
-      next();
-      return capability.promise;
-    }
-  }, {
-    key: "getPageIndex",
-    value: function getPageIndex(pageRef) {
-      var xref = this.xref;
-
-      function pagesBeforeRef(kidRef) {
-        var total = 0,
-            parentRef;
-        return xref.fetchAsync(kidRef).then(function (node) {
-          if ((0, _primitives.isRefsEqual)(kidRef, pageRef) && !(0, _primitives.isDict)(node, 'Page') && !((0, _primitives.isDict)(node) && !node.has('Type') && node.has('Contents'))) {
-            throw new _util.FormatError('The reference does not point to a /Page dictionary.');
-          }
+              default:
+                prefValue = "AppDefault";
+            }
 
-          if (!node) {
-            return null;
-          }
+            break;
 
-          if (!(0, _primitives.isDict)(node)) {
-            throw new _util.FormatError('Node must be a dictionary.');
-          }
+          case "Duplex":
+            switch (value.name) {
+              case "Simplex":
+              case "DuplexFlipShortEdge":
+              case "DuplexFlipLongEdge":
+                prefValue = value.name;
+                break;
 
-          parentRef = node.getRaw('Parent');
-          return node.getAsync('Parent');
-        }).then(function (parent) {
-          if (!parent) {
-            return null;
-          }
+              default:
+                prefValue = "None";
+            }
 
-          if (!(0, _primitives.isDict)(parent)) {
-            throw new _util.FormatError('Parent must be a dictionary.');
-          }
+            break;
 
-          return parent.getAsync('Kids');
-        }).then(function (kids) {
-          if (!kids) {
-            return null;
-          }
+          case "PrintPageRange":
+            const length = value.length;
 
-          var kidPromises = [];
-          var found = false;
+            if (length % 2 !== 0) {
+              break;
+            }
 
-          for (var i = 0, ii = kids.length; i < ii; i++) {
-            var kid = kids[i];
+            const isValid = value.every((page, i, arr) => {
+              return Number.isInteger(page) && page > 0 && (i === 0 || page >= arr[i - 1]) && page <= this.numPages;
+            });
 
-            if (!(0, _primitives.isRef)(kid)) {
-              throw new _util.FormatError('Kid must be a reference.');
+            if (isValid) {
+              prefValue = value;
             }
 
-            if ((0, _primitives.isRefsEqual)(kid, kidRef)) {
-              found = true;
-              break;
+            break;
+
+          case "NumCopies":
+            if (value > 0) {
+              prefValue = value;
             }
 
-            kidPromises.push(xref.fetchAsync(kid).then(function (kid) {
-              if (!(0, _primitives.isDict)(kid)) {
-                throw new _util.FormatError('Kid node must be a dictionary.');
-              }
+            break;
 
-              if (kid.has('Count')) {
-                total += kid.get('Count');
-              } else {
-                total++;
-              }
-            }));
-          }
+          default:
+            if (typeof value !== "boolean") {
+              throw new _util.FormatError(`viewerPreferences - expected a boolean value for: ${key}`);
+            }
 
-          if (!found) {
-            throw new _util.FormatError('Kid reference not found in parent\'s kids.');
+            prefValue = value;
+        }
+
+        if (prefValue !== undefined) {
+          if (!prefs) {
+            prefs = Object.create(null);
           }
 
-          return Promise.all(kidPromises).then(function () {
-            return [total, parentRef];
-          });
-        });
+          prefs[key] = prefValue;
+        } else {
+          (0, _util.info)(`Bad value in ViewerPreferences for "${key}".`);
+        }
       }
+    }
+
+    return (0, _util.shadow)(this, "viewerPreferences", prefs);
+  }
 
-      var total = 0;
+  get openAction() {
+    const obj = this.catDict.get("OpenAction");
+    let openAction = null;
+
+    if ((0, _primitives.isDict)(obj)) {
+      const destDict = new _primitives.Dict(this.xref);
+      destDict.set("A", obj);
+      const resultObj = {
+        url: null,
+        dest: null,
+        action: null
+      };
+      Catalog.parseDestDictionary({
+        destDict,
+        resultObj
+      });
 
-      function next(ref) {
-        return pagesBeforeRef(ref).then(function (args) {
-          if (!args) {
-            return total;
-          }
+      if (Array.isArray(resultObj.dest)) {
+        if (!openAction) {
+          openAction = Object.create(null);
+        }
 
-          var _args = _slicedToArray(args, 2),
-              count = _args[0],
-              parentRef = _args[1];
+        openAction.dest = resultObj.dest;
+      } else if (resultObj.action) {
+        if (!openAction) {
+          openAction = Object.create(null);
+        }
 
-          total += count;
-          return next(parentRef);
-        });
+        openAction.action = resultObj.action;
+      }
+    } else if (Array.isArray(obj)) {
+      if (!openAction) {
+        openAction = Object.create(null);
       }
 
-      return next(pageRef);
+      openAction.dest = obj;
     }
-  }, {
-    key: "metadata",
-    get: function get() {
-      var streamRef = this.catDict.getRaw('Metadata');
 
-      if (!(0, _primitives.isRef)(streamRef)) {
-        return (0, _util.shadow)(this, 'metadata', null);
-      }
+    return (0, _util.shadow)(this, "openAction", openAction);
+  }
 
-      var suppressEncryption = !(this.xref.encrypt && this.xref.encrypt.encryptMetadata);
-      var stream = this.xref.fetch(streamRef, suppressEncryption);
-      var metadata;
+  get attachments() {
+    const obj = this.catDict.get("Names");
+    let attachments = null;
 
-      if (stream && (0, _primitives.isDict)(stream.dict)) {
-        var type = stream.dict.get('Type');
-        var subtype = stream.dict.get('Subtype');
+    if (obj && obj.has("EmbeddedFiles")) {
+      const nameTree = new NameTree(obj.getRaw("EmbeddedFiles"), this.xref);
+      const names = nameTree.getAll();
 
-        if ((0, _primitives.isName)(type, 'Metadata') && (0, _primitives.isName)(subtype, 'XML')) {
-          try {
-            metadata = (0, _util.stringToUTF8String)((0, _util.bytesToString)(stream.getBytes()));
-          } catch (e) {
-            if (e instanceof _util.MissingDataException) {
-              throw e;
-            }
+      for (const name in names) {
+        const fs = new FileSpec(names[name], this.xref);
 
-            (0, _util.info)('Skipping invalid metadata.');
-          }
+        if (!attachments) {
+          attachments = Object.create(null);
         }
-      }
 
-      return (0, _util.shadow)(this, 'metadata', metadata);
+        attachments[(0, _util.stringToPDFString)(name)] = fs.serializable;
+      }
     }
-  }, {
-    key: "toplevelPagesDict",
-    get: function get() {
-      var pagesObj = this.catDict.get('Pages');
 
-      if (!(0, _primitives.isDict)(pagesObj)) {
-        throw new _util.FormatError('Invalid top-level pages dictionary.');
-      }
+    return (0, _util.shadow)(this, "attachments", attachments);
+  }
 
-      return (0, _util.shadow)(this, 'toplevelPagesDict', pagesObj);
-    }
-  }, {
-    key: "documentOutline",
-    get: function get() {
-      var obj = null;
+  get javaScript() {
+    const obj = this.catDict.get("Names");
+    let javaScript = null;
 
-      try {
-        obj = this._readDocumentOutline();
-      } catch (ex) {
-        if (ex instanceof _util.MissingDataException) {
-          throw ex;
-        }
+    function appendIfJavaScriptDict(jsDict) {
+      const type = jsDict.get("S");
 
-        (0, _util.warn)('Unable to read document outline.');
+      if (!(0, _primitives.isName)(type, "JavaScript")) {
+        return;
       }
 
-      return (0, _util.shadow)(this, 'documentOutline', obj);
-    }
-  }, {
-    key: "permissions",
-    get: function get() {
-      var permissions = null;
+      let js = jsDict.get("JS");
 
-      try {
-        permissions = this._readPermissions();
-      } catch (ex) {
-        if (ex instanceof _util.MissingDataException) {
-          throw ex;
-        }
+      if ((0, _primitives.isStream)(js)) {
+        js = (0, _util.bytesToString)(js.getBytes());
+      } else if (!(0, _util.isString)(js)) {
+        return;
+      }
 
-        (0, _util.warn)('Unable to read permissions.');
+      if (!javaScript) {
+        javaScript = [];
       }
 
-      return (0, _util.shadow)(this, 'permissions', permissions);
+      javaScript.push((0, _util.stringToPDFString)(js));
     }
-  }, {
-    key: "numPages",
-    get: function get() {
-      var obj = this.toplevelPagesDict.get('Count');
 
-      if (!Number.isInteger(obj)) {
-        throw new _util.FormatError('Page count in top-level pages dictionary is not an integer.');
+    if (obj && obj.has("JavaScript")) {
+      const nameTree = new NameTree(obj.getRaw("JavaScript"), this.xref);
+      const names = nameTree.getAll();
+
+      for (const name in names) {
+        const jsDict = names[name];
+
+        if ((0, _primitives.isDict)(jsDict)) {
+          appendIfJavaScriptDict(jsDict);
+        }
       }
+    }
 
-      return (0, _util.shadow)(this, 'numPages', obj);
+    const openAction = this.catDict.get("OpenAction");
+
+    if ((0, _primitives.isDict)(openAction) && (0, _primitives.isName)(openAction.get("S"), "JavaScript")) {
+      appendIfJavaScriptDict(openAction);
     }
-  }, {
-    key: "destinations",
-    get: function get() {
-      var obj = this._readDests(),
-          dests = Object.create(null);
 
-      if (obj instanceof NameTree) {
-        var names = obj.getAll();
+    return (0, _util.shadow)(this, "javaScript", javaScript);
+  }
 
-        for (var name in names) {
-          dests[name] = fetchDestination(names[name]);
+  fontFallback(id, handler) {
+    const promises = [];
+    this.fontCache.forEach(function (promise) {
+      promises.push(promise);
+    });
+    return Promise.all(promises).then(translatedFonts => {
+      for (const translatedFont of translatedFonts) {
+        if (translatedFont.loadedName === id) {
+          translatedFont.fallback(handler);
+          return;
         }
-      } else if (obj instanceof _primitives.Dict) {
-        obj.forEach(function (key, value) {
-          if (value) {
-            dests[key] = fetchDestination(value);
-          }
-        });
       }
+    });
+  }
 
-      return (0, _util.shadow)(this, 'destinations', dests);
-    }
-  }, {
-    key: "pageLabels",
-    get: function get() {
-      var obj = null;
+  cleanup(manuallyTriggered = false) {
+    (0, _primitives.clearPrimitiveCaches)();
+    this.globalImageCache.clear(manuallyTriggered);
+    this.pageKidsCountCache.clear();
+    const promises = [];
+    this.fontCache.forEach(function (promise) {
+      promises.push(promise);
+    });
+    return Promise.all(promises).then(translatedFonts => {
+      for (const {
+        dict
+      } of translatedFonts) {
+        delete dict.translated;
+      }
+
+      this.fontCache.clear();
+      this.builtInCMapCache.clear();
+    });
+  }
 
-      try {
-        obj = this._readPageLabels();
-      } catch (ex) {
-        if (ex instanceof _util.MissingDataException) {
-          throw ex;
-        }
+  getPageDict(pageIndex) {
+    const capability = (0, _util.createPromiseCapability)();
+    const nodesToVisit = [this.catDict.getRaw("Pages")];
+    const visitedNodes = new _primitives.RefSet();
+    const xref = this.xref,
+          pageKidsCountCache = this.pageKidsCountCache;
+    let count,
+        currentPageIndex = 0;
 
-        (0, _util.warn)('Unable to read page labels.');
-      }
+    function next() {
+      while (nodesToVisit.length) {
+        const currentNode = nodesToVisit.pop();
 
-      return (0, _util.shadow)(this, 'pageLabels', obj);
-    }
-  }, {
-    key: "pageMode",
-    get: function get() {
-      var obj = this.catDict.get('PageMode');
-      var pageMode = 'UseNone';
+        if ((0, _primitives.isRef)(currentNode)) {
+          count = pageKidsCountCache.get(currentNode);
 
-      if ((0, _primitives.isName)(obj)) {
-        switch (obj.name) {
-          case 'UseNone':
-          case 'UseOutlines':
-          case 'UseThumbs':
-          case 'FullScreen':
-          case 'UseOC':
-          case 'UseAttachments':
-            pageMode = obj.name;
-        }
-      }
+          if (count > 0 && currentPageIndex + count < pageIndex) {
+            currentPageIndex += count;
+            continue;
+          }
 
-      return (0, _util.shadow)(this, 'pageMode', pageMode);
-    }
-  }, {
-    key: "openActionDestination",
-    get: function get() {
-      var obj = this.catDict.get('OpenAction');
-      var openActionDest = null;
-
-      if ((0, _primitives.isDict)(obj)) {
-        var destDict = new _primitives.Dict(this.xref);
-        destDict.set('A', obj);
-        var resultObj = {
-          url: null,
-          dest: null
-        };
-        Catalog.parseDestDictionary({
-          destDict: destDict,
-          resultObj: resultObj
-        });
+          if (visitedNodes.has(currentNode)) {
+            capability.reject(new _util.FormatError("Pages tree contains circular reference."));
+            return;
+          }
+
+          visitedNodes.put(currentNode);
+          xref.fetchAsync(currentNode).then(function (obj) {
+            if ((0, _primitives.isDict)(obj, "Page") || (0, _primitives.isDict)(obj) && !obj.has("Kids")) {
+              if (pageIndex === currentPageIndex) {
+                if (currentNode && !pageKidsCountCache.has(currentNode)) {
+                  pageKidsCountCache.put(currentNode, 1);
+                }
+
+                capability.resolve([obj, currentNode]);
+              } else {
+                currentPageIndex++;
+                next();
+              }
+
+              return;
+            }
 
-        if (Array.isArray(resultObj.dest)) {
-          openActionDest = resultObj.dest;
+            nodesToVisit.push(obj);
+            next();
+          }, capability.reject);
+          return;
         }
-      } else if (Array.isArray(obj)) {
-        openActionDest = obj;
-      }
 
-      return (0, _util.shadow)(this, 'openActionDestination', openActionDest);
-    }
-  }, {
-    key: "attachments",
-    get: function get() {
-      var obj = this.catDict.get('Names');
-      var attachments = null;
+        if (!(0, _primitives.isDict)(currentNode)) {
+          capability.reject(new _util.FormatError("Page dictionary kid reference points to wrong type of object."));
+          return;
+        }
 
-      if (obj && obj.has('EmbeddedFiles')) {
-        var nameTree = new NameTree(obj.getRaw('EmbeddedFiles'), this.xref);
-        var names = nameTree.getAll();
+        count = currentNode.get("Count");
 
-        for (var name in names) {
-          var fs = new FileSpec(names[name], this.xref);
+        if (Number.isInteger(count) && count >= 0) {
+          const objId = currentNode.objId;
 
-          if (!attachments) {
-            attachments = Object.create(null);
+          if (objId && !pageKidsCountCache.has(objId)) {
+            pageKidsCountCache.put(objId, count);
           }
 
-          attachments[(0, _util.stringToPDFString)(name)] = fs.serializable;
+          if (currentPageIndex + count <= pageIndex) {
+            currentPageIndex += count;
+            continue;
+          }
         }
-      }
 
-      return (0, _util.shadow)(this, 'attachments', attachments);
-    }
-  }, {
-    key: "javaScript",
-    get: function get() {
-      var obj = this.catDict.get('Names');
-      var javaScript = null;
+        const kids = currentNode.get("Kids");
+
+        if (!Array.isArray(kids)) {
+          if ((0, _primitives.isName)(currentNode.get("Type"), "Page") || !currentNode.has("Type") && currentNode.has("Contents")) {
+            if (currentPageIndex === pageIndex) {
+              capability.resolve([currentNode, null]);
+              return;
+            }
 
-      function appendIfJavaScriptDict(jsDict) {
-        var type = jsDict.get('S');
+            currentPageIndex++;
+            continue;
+          }
 
-        if (!(0, _primitives.isName)(type, 'JavaScript')) {
+          capability.reject(new _util.FormatError("Page dictionary kids object is not an array."));
           return;
         }
 
-        var js = jsDict.get('JS');
+        for (let last = kids.length - 1; last >= 0; last--) {
+          nodesToVisit.push(kids[last]);
+        }
+      }
+
+      capability.reject(new Error(`Page index ${pageIndex} not found.`));
+    }
 
-        if ((0, _primitives.isStream)(js)) {
-          js = (0, _util.bytesToString)(js.getBytes());
-        } else if (!(0, _util.isString)(js)) {
-          return;
+    next();
+    return capability.promise;
+  }
+
+  getPageIndex(pageRef) {
+    const xref = this.xref;
+
+    function pagesBeforeRef(kidRef) {
+      let total = 0,
+          parentRef;
+      return xref.fetchAsync(kidRef).then(function (node) {
+        if ((0, _primitives.isRefsEqual)(kidRef, pageRef) && !(0, _primitives.isDict)(node, "Page") && !((0, _primitives.isDict)(node) && !node.has("Type") && node.has("Contents"))) {
+          throw new _util.FormatError("The reference does not point to a /Page dictionary.");
         }
 
-        if (!javaScript) {
-          javaScript = [];
+        if (!node) {
+          return null;
         }
 
-        javaScript.push((0, _util.stringToPDFString)(js));
-      }
+        if (!(0, _primitives.isDict)(node)) {
+          throw new _util.FormatError("Node must be a dictionary.");
+        }
 
-      if (obj && obj.has('JavaScript')) {
-        var nameTree = new NameTree(obj.getRaw('JavaScript'), this.xref);
-        var names = nameTree.getAll();
+        parentRef = node.getRaw("Parent");
+        return node.getAsync("Parent");
+      }).then(function (parent) {
+        if (!parent) {
+          return null;
+        }
 
-        for (var name in names) {
-          var jsDict = names[name];
+        if (!(0, _primitives.isDict)(parent)) {
+          throw new _util.FormatError("Parent must be a dictionary.");
+        }
 
-          if ((0, _primitives.isDict)(jsDict)) {
-            appendIfJavaScriptDict(jsDict);
-          }
+        return parent.getAsync("Kids");
+      }).then(function (kids) {
+        if (!kids) {
+          return null;
         }
-      }
 
-      var openActionDict = this.catDict.get('OpenAction');
+        const kidPromises = [];
+        let found = false;
 
-      if ((0, _primitives.isDict)(openActionDict, 'Action')) {
-        var actionType = openActionDict.get('S');
+        for (let i = 0, ii = kids.length; i < ii; i++) {
+          const kid = kids[i];
+
+          if (!(0, _primitives.isRef)(kid)) {
+            throw new _util.FormatError("Kid must be a reference.");
+          }
+
+          if ((0, _primitives.isRefsEqual)(kid, kidRef)) {
+            found = true;
+            break;
+          }
 
-        if ((0, _primitives.isName)(actionType, 'Named')) {
-          var action = openActionDict.get('N');
+          kidPromises.push(xref.fetchAsync(kid).then(function (obj) {
+            if (!(0, _primitives.isDict)(obj)) {
+              throw new _util.FormatError("Kid node must be a dictionary.");
+            }
 
-          if ((0, _primitives.isName)(action, 'Print')) {
-            if (!javaScript) {
-              javaScript = [];
+            if (obj.has("Count")) {
+              total += obj.get("Count");
+            } else {
+              total++;
             }
+          }));
+        }
 
-            javaScript.push('print({});');
-          }
-        } else {
-          appendIfJavaScriptDict(openActionDict);
+        if (!found) {
+          throw new _util.FormatError("Kid reference not found in parent's kids.");
         }
-      }
 
-      return (0, _util.shadow)(this, 'javaScript', javaScript);
+        return Promise.all(kidPromises).then(function () {
+          return [total, parentRef];
+        });
+      });
     }
-  }], [{
-    key: "parseDestDictionary",
-    value: function parseDestDictionary(params) {
-      function addDefaultProtocolToUrl(url) {
-        return url.startsWith('www.') ? "http://".concat(url) : url;
-      }
 
-      function tryConvertUrlEncoding(url) {
-        try {
-          return (0, _util.stringToUTF8String)(url);
-        } catch (e) {
-          return url;
+    let total = 0;
+
+    function next(ref) {
+      return pagesBeforeRef(ref).then(function (args) {
+        if (!args) {
+          return total;
         }
-      }
 
-      var destDict = params.destDict;
+        const [count, parentRef] = args;
+        total += count;
+        return next(parentRef);
+      });
+    }
 
-      if (!(0, _primitives.isDict)(destDict)) {
-        (0, _util.warn)('parseDestDictionary: `destDict` must be a dictionary.');
-        return;
-      }
+    return next(pageRef);
+  }
 
-      var resultObj = params.resultObj;
+  static parseDestDictionary(params) {
+    function addDefaultProtocolToUrl(url) {
+      return url.startsWith("www.") ? `http://${url}` : url;
+    }
 
-      if (_typeof(resultObj) !== 'object') {
-        (0, _util.warn)('parseDestDictionary: `resultObj` must be an object.');
-        return;
+    function tryConvertUrlEncoding(url) {
+      try {
+        return (0, _util.stringToUTF8String)(url);
+      } catch (e) {
+        return url;
       }
+    }
 
-      var docBaseUrl = params.docBaseUrl || null;
-      var action = destDict.get('A'),
-          url,
-          dest;
+    const destDict = params.destDict;
 
-      if (!(0, _primitives.isDict)(action) && destDict.has('Dest')) {
-        action = destDict.get('Dest');
-      }
+    if (!(0, _primitives.isDict)(destDict)) {
+      (0, _util.warn)("parseDestDictionary: `destDict` must be a dictionary.");
+      return;
+    }
 
-      if ((0, _primitives.isDict)(action)) {
-        var actionType = action.get('S');
+    const resultObj = params.resultObj;
 
-        if (!(0, _primitives.isName)(actionType)) {
-          (0, _util.warn)('parseDestDictionary: Invalid type in Action dictionary.');
-          return;
-        }
+    if (typeof resultObj !== "object") {
+      (0, _util.warn)("parseDestDictionary: `resultObj` must be an object.");
+      return;
+    }
 
-        var actionName = actionType.name;
+    const docBaseUrl = params.docBaseUrl || null;
+    let action = destDict.get("A"),
+        url,
+        dest;
 
-        switch (actionName) {
-          case 'URI':
-            url = action.get('URI');
+    if (!(0, _primitives.isDict)(action) && destDict.has("Dest")) {
+      action = destDict.get("Dest");
+    }
 
-            if ((0, _primitives.isName)(url)) {
-              url = '/' + url.name;
-            } else if ((0, _util.isString)(url)) {
-              url = addDefaultProtocolToUrl(url);
-            }
+    if ((0, _primitives.isDict)(action)) {
+      const actionType = action.get("S");
 
-            break;
+      if (!(0, _primitives.isName)(actionType)) {
+        (0, _util.warn)("parseDestDictionary: Invalid type in Action dictionary.");
+        return;
+      }
 
-          case 'GoTo':
-            dest = action.get('D');
-            break;
+      const actionName = actionType.name;
 
-          case 'Launch':
-          case 'GoToR':
-            var urlDict = action.get('F');
+      switch (actionName) {
+        case "URI":
+          url = action.get("URI");
 
-            if ((0, _primitives.isDict)(urlDict)) {
-              url = urlDict.get('F') || null;
-            } else if ((0, _util.isString)(urlDict)) {
-              url = urlDict;
-            }
+          if ((0, _primitives.isName)(url)) {
+            url = "/" + url.name;
+          } else if ((0, _util.isString)(url)) {
+            url = addDefaultProtocolToUrl(url);
+          }
 
-            var remoteDest = action.get('D');
+          break;
 
-            if (remoteDest) {
-              if ((0, _primitives.isName)(remoteDest)) {
-                remoteDest = remoteDest.name;
-              }
+        case "GoTo":
+          dest = action.get("D");
+          break;
 
-              if ((0, _util.isString)(url)) {
-                var baseUrl = url.split('#')[0];
+        case "Launch":
+        case "GoToR":
+          const urlDict = action.get("F");
 
-                if ((0, _util.isString)(remoteDest)) {
-                  url = baseUrl + '#' + remoteDest;
-                } else if (Array.isArray(remoteDest)) {
-                  url = baseUrl + '#' + JSON.stringify(remoteDest);
-                }
-              }
+          if ((0, _primitives.isDict)(urlDict)) {
+            url = urlDict.get("F") || null;
+          } else if ((0, _util.isString)(urlDict)) {
+            url = urlDict;
+          }
+
+          let remoteDest = action.get("D");
+
+          if (remoteDest) {
+            if ((0, _primitives.isName)(remoteDest)) {
+              remoteDest = remoteDest.name;
             }
 
-            var newWindow = action.get('NewWindow');
+            if ((0, _util.isString)(url)) {
+              const baseUrl = url.split("#")[0];
 
-            if ((0, _util.isBool)(newWindow)) {
-              resultObj.newWindow = newWindow;
+              if ((0, _util.isString)(remoteDest)) {
+                url = baseUrl + "#" + remoteDest;
+              } else if (Array.isArray(remoteDest)) {
+                url = baseUrl + "#" + JSON.stringify(remoteDest);
+              }
             }
+          }
 
-            break;
+          const newWindow = action.get("NewWindow");
 
-          case 'Named':
-            var namedAction = action.get('N');
+          if ((0, _util.isBool)(newWindow)) {
+            resultObj.newWindow = newWindow;
+          }
 
-            if ((0, _primitives.isName)(namedAction)) {
-              resultObj.action = namedAction.name;
-            }
+          break;
 
-            break;
+        case "Named":
+          const namedAction = action.get("N");
 
-          case 'JavaScript':
-            var jsAction = action.get('JS');
-            var js;
+          if ((0, _primitives.isName)(namedAction)) {
+            resultObj.action = namedAction.name;
+          }
 
-            if ((0, _primitives.isStream)(jsAction)) {
-              js = (0, _util.bytesToString)(jsAction.getBytes());
-            } else if ((0, _util.isString)(jsAction)) {
-              js = jsAction;
-            }
+          break;
 
-            if (js) {
-              var URL_OPEN_METHODS = ['app.launchURL', 'window.open'];
-              var regex = new RegExp('^\\s*(' + URL_OPEN_METHODS.join('|').split('.').join('\\.') + ')\\((?:\'|\")([^\'\"]*)(?:\'|\")(?:,\\s*(\\w+)\\)|\\))', 'i');
-              var jsUrl = regex.exec((0, _util.stringToPDFString)(js));
+        case "JavaScript":
+          const jsAction = action.get("JS");
+          let js;
 
-              if (jsUrl && jsUrl[2]) {
-                url = jsUrl[2];
+          if ((0, _primitives.isStream)(jsAction)) {
+            js = (0, _util.bytesToString)(jsAction.getBytes());
+          } else if ((0, _util.isString)(jsAction)) {
+            js = jsAction;
+          }
 
-                if (jsUrl[3] === 'true' && jsUrl[1] === 'app.launchURL') {
-                  resultObj.newWindow = true;
-                }
+          if (js) {
+            const URL_OPEN_METHODS = ["app.launchURL", "window.open"];
+            const regex = new RegExp("^\\s*(" + URL_OPEN_METHODS.join("|").split(".").join("\\.") + ")\\((?:'|\")([^'\"]*)(?:'|\")(?:,\\s*(\\w+)\\)|\\))", "i");
+            const jsUrl = regex.exec((0, _util.stringToPDFString)(js));
 
-                break;
+            if (jsUrl && jsUrl[2]) {
+              url = jsUrl[2];
+
+              if (jsUrl[3] === "true" && jsUrl[1] === "app.launchURL") {
+                resultObj.newWindow = true;
               }
+
+              break;
             }
+          }
 
-          default:
-            (0, _util.warn)("parseDestDictionary: unsupported action type \"".concat(actionName, "\"."));
-            break;
-        }
-      } else if (destDict.has('Dest')) {
-        dest = destDict.get('Dest');
+        default:
+          (0, _util.warn)(`parseDestDictionary: unsupported action type "${actionName}".`);
+          break;
       }
+    } else if (destDict.has("Dest")) {
+      dest = destDict.get("Dest");
+    }
 
-      if ((0, _util.isString)(url)) {
-        url = tryConvertUrlEncoding(url);
-        var absoluteUrl = (0, _util.createValidAbsoluteUrl)(url, docBaseUrl);
-
-        if (absoluteUrl) {
-          resultObj.url = absoluteUrl.href;
-        }
+    if ((0, _util.isString)(url)) {
+      url = tryConvertUrlEncoding(url);
+      const absoluteUrl = (0, _util.createValidAbsoluteUrl)(url, docBaseUrl);
 
-        resultObj.unsafeUrl = url;
+      if (absoluteUrl) {
+        resultObj.url = absoluteUrl.href;
       }
 
-      if (dest) {
-        if ((0, _primitives.isName)(dest)) {
-          dest = dest.name;
-        }
+      resultObj.unsafeUrl = url;
+    }
 
-        if ((0, _util.isString)(dest) || Array.isArray(dest)) {
-          resultObj.dest = dest;
-        }
+    if (dest) {
+      if ((0, _primitives.isName)(dest)) {
+        dest = dest.name;
+      }
+
+      if ((0, _util.isString)(dest) || Array.isArray(dest)) {
+        resultObj.dest = dest;
       }
     }
-  }]);
+  }
 
-  return Catalog;
-}();
+}
 
 exports.Catalog = Catalog;
 
@@ -1047,10 +1134,10 @@ var XRef = function XRefClosure() {
     this.pdfManager = pdfManager;
     this.entries = [];
     this.xrefstms = Object.create(null);
-    this.cache = [];
+    this._cacheMap = new Map();
     this.stats = {
-      streamTypes: [],
-      fontTypes: []
+      streamTypes: Object.create(null),
+      fontTypes: Object.create(null)
     };
   }
 
@@ -1064,55 +1151,55 @@ var XRef = function XRefClosure() {
       if (!recoveryMode) {
         trailerDict = this.readXRef();
       } else {
-        (0, _util.warn)('Indexing all PDF objects');
+        (0, _util.warn)("Indexing all PDF objects");
         trailerDict = this.indexObjects();
       }
 
       trailerDict.assignXref(this);
       this.trailer = trailerDict;
-      var encrypt;
+      let encrypt;
 
       try {
-        encrypt = trailerDict.get('Encrypt');
+        encrypt = trailerDict.get("Encrypt");
       } catch (ex) {
-        if (ex instanceof _util.MissingDataException) {
+        if (ex instanceof _core_utils.MissingDataException) {
           throw ex;
         }
 
-        (0, _util.warn)("XRef.parse - Invalid \"Encrypt\" reference: \"".concat(ex, "\"."));
+        (0, _util.warn)(`XRef.parse - Invalid "Encrypt" reference: "${ex}".`);
       }
 
       if ((0, _primitives.isDict)(encrypt)) {
-        var ids = trailerDict.get('ID');
-        var fileId = ids && ids.length ? ids[0] : '';
+        var ids = trailerDict.get("ID");
+        var fileId = ids && ids.length ? ids[0] : "";
         encrypt.suppressEncryption = true;
         this.encrypt = new _crypto.CipherTransformFactory(encrypt, fileId, this.pdfManager.password);
       }
 
-      var root;
+      let root;
 
       try {
-        root = trailerDict.get('Root');
+        root = trailerDict.get("Root");
       } catch (ex) {
-        if (ex instanceof _util.MissingDataException) {
+        if (ex instanceof _core_utils.MissingDataException) {
           throw ex;
         }
 
-        (0, _util.warn)("XRef.parse - Invalid \"Root\" reference: \"".concat(ex, "\"."));
+        (0, _util.warn)(`XRef.parse - Invalid "Root" reference: "${ex}".`);
       }
 
-      if ((0, _primitives.isDict)(root) && root.has('Pages')) {
+      if ((0, _primitives.isDict)(root) && root.has("Pages")) {
         this.root = root;
       } else {
         if (!recoveryMode) {
-          throw new _util.XRefParseException();
+          throw new _core_utils.XRefParseException();
         }
 
-        throw new _util.FormatError('Invalid root reference');
+        throw new _util.FormatError("Invalid root reference");
       }
     },
     processXRefTable: function XRef_processXRefTable(parser) {
-      if (!('tableState' in this)) {
+      if (!("tableState" in this)) {
         this.tableState = {
           entryNum: 0,
           streamPos: parser.lexer.stream.pos,
@@ -1123,8 +1210,8 @@ var XRef = function XRefClosure() {
 
       var obj = this.readXRefTable(parser);
 
-      if (!(0, _primitives.isCmd)(obj, 'trailer')) {
-        throw new _util.FormatError('Invalid XRef table: could not find trailer dictionary');
+      if (!(0, _primitives.isCmd)(obj, "trailer")) {
+        throw new _util.FormatError("Invalid XRef table: could not find trailer dictionary");
       }
 
       var dict = parser.getObj();
@@ -1134,7 +1221,7 @@ var XRef = function XRefClosure() {
       }
 
       if (!(0, _primitives.isDict)(dict)) {
-        throw new _util.FormatError('Invalid XRef table: could not parse trailer dictionary');
+        throw new _util.FormatError("Invalid XRef table: could not parse trailer dictionary");
       }
 
       delete this.tableState;
@@ -1149,8 +1236,8 @@ var XRef = function XRefClosure() {
       var obj;
 
       while (true) {
-        if (!('firstEntryNum' in tableState) || !('entryCount' in tableState)) {
-          if ((0, _primitives.isCmd)(obj = parser.getObj(), 'trailer')) {
+        if (!("firstEntryNum" in tableState) || !("entryCount" in tableState)) {
+          if ((0, _primitives.isCmd)(obj = parser.getObj(), "trailer")) {
             break;
           }
 
@@ -1162,7 +1249,7 @@ var XRef = function XRefClosure() {
         var count = tableState.entryCount;
 
         if (!Number.isInteger(first) || !Number.isInteger(count)) {
-          throw new _util.FormatError('Invalid XRef table: wrong types in subsection header');
+          throw new _util.FormatError("Invalid XRef table: wrong types in subsection header");
         }
 
         for (var i = tableState.entryNum; i < count; i++) {
@@ -1175,14 +1262,20 @@ var XRef = function XRefClosure() {
           entry.gen = parser.getObj();
           var type = parser.getObj();
 
-          if ((0, _primitives.isCmd)(type, 'f')) {
-            entry.free = true;
-          } else if ((0, _primitives.isCmd)(type, 'n')) {
-            entry.uncompressed = true;
+          if (type instanceof _primitives.Cmd) {
+            switch (type.cmd) {
+              case "f":
+                entry.free = true;
+                break;
+
+              case "n":
+                entry.uncompressed = true;
+                break;
+            }
           }
 
           if (!Number.isInteger(entry.offset) || !Number.isInteger(entry.gen) || !(entry.free || entry.uncompressed)) {
-            throw new _util.FormatError("Invalid entry in XRef subsection: ".concat(first, ", ").concat(count));
+            throw new _util.FormatError(`Invalid entry in XRef subsection: ${first}, ${count}`);
           }
 
           if (i === 0 && entry.free && first === 1) {
@@ -1203,24 +1296,24 @@ var XRef = function XRefClosure() {
       }
 
       if (this.entries[0] && !this.entries[0].free) {
-        throw new _util.FormatError('Invalid XRef table: unexpected first object');
+        throw new _util.FormatError("Invalid XRef table: unexpected first object");
       }
 
       return obj;
     },
     processXRefStream: function XRef_processXRefStream(stream) {
-      if (!('streamState' in this)) {
+      if (!("streamState" in this)) {
         var streamParameters = stream.dict;
-        var byteWidths = streamParameters.get('W');
-        var range = streamParameters.get('Index');
+        var byteWidths = streamParameters.get("W");
+        var range = streamParameters.get("Index");
 
         if (!range) {
-          range = [0, streamParameters.get('Size')];
+          range = [0, streamParameters.get("Size")];
         }
 
         this.streamState = {
           entryRanges: range,
-          byteWidths: byteWidths,
+          byteWidths,
           entryNum: 0,
           streamPos: stream.pos
         };
@@ -1245,11 +1338,11 @@ var XRef = function XRefClosure() {
         var n = entryRanges[1];
 
         if (!Number.isInteger(first) || !Number.isInteger(n)) {
-          throw new _util.FormatError("Invalid XRef range fields: ".concat(first, ", ").concat(n));
+          throw new _util.FormatError(`Invalid XRef range fields: ${first}, ${n}`);
         }
 
         if (!Number.isInteger(typeFieldWidth) || !Number.isInteger(offsetFieldWidth) || !Number.isInteger(generationFieldWidth)) {
-          throw new _util.FormatError("Invalid XRef entry fields length: ".concat(first, ", ").concat(n));
+          throw new _util.FormatError(`Invalid XRef entry fields length: ${first}, ${n}`);
         }
 
         for (i = streamState.entryNum; i < n; ++i) {
@@ -1292,7 +1385,7 @@ var XRef = function XRefClosure() {
               break;
 
             default:
-              throw new _util.FormatError("Invalid XRef entry type: ".concat(type));
+              throw new _util.FormatError(`Invalid XRef entry type: ${type}`);
           }
 
           if (!this.entries[first + i]) {
@@ -1307,14 +1400,14 @@ var XRef = function XRefClosure() {
     },
     indexObjects: function XRef_indexObjects() {
       var TAB = 0x9,
-          LF = 0xA,
-          CR = 0xD,
+          LF = 0xa,
+          CR = 0xd,
           SPACE = 0x20;
       var PERCENT = 0x25,
-          LT = 0x3C;
+          LT = 0x3c;
 
       function readToken(data, offset) {
-        var token = '',
+        var token = "",
             ch = data[offset];
 
         while (ch !== LF && ch !== CR && ch !== LT) {
@@ -1353,12 +1446,12 @@ var XRef = function XRefClosure() {
       }
 
       var objRegExp = /^(\d+)\s+(\d+)\s+obj\b/;
-      var endobjRegExp = /\bendobj[\b\s]$/;
-      var nestedObjRegExp = /\s+(\d+\s+\d+\s+obj[\b\s<])$/;
-      var CHECK_CONTENT_LENGTH = 25;
+      const endobjRegExp = /\bendobj[\b\s]$/;
+      const nestedObjRegExp = /\s+(\d+\s+\d+\s+obj[\b\s<])$/;
+      const CHECK_CONTENT_LENGTH = 25;
       var trailerBytes = new Uint8Array([116, 114, 97, 105, 108, 101, 114]);
       var startxrefBytes = new Uint8Array([115, 116, 97, 114, 116, 120, 114, 101, 102]);
-      var objBytes = new Uint8Array([111, 98, 106]);
+      const objBytes = new Uint8Array([111, 98, 106]);
       var xrefBytes = new Uint8Array([47, 88, 82, 101, 102]);
       this.entries.length = 0;
       var stream = this.stream;
@@ -1394,35 +1487,35 @@ var XRef = function XRefClosure() {
         var token = readToken(buffer, position);
         var m;
 
-        if (token.startsWith('xref') && (token.length === 4 || /\s/.test(token[4]))) {
+        if (token.startsWith("xref") && (token.length === 4 || /\s/.test(token[4]))) {
           position += skipUntil(buffer, position, trailerBytes);
           trailers.push(position);
           position += skipUntil(buffer, position, startxrefBytes);
         } else if (m = objRegExp.exec(token)) {
-          var num = m[1] | 0,
-              gen = m[2] | 0;
+          const num = m[1] | 0,
+                gen = m[2] | 0;
 
-          if (typeof this.entries[num] === 'undefined') {
+          if (!this.entries[num] || this.entries[num].gen === gen) {
             this.entries[num] = {
               offset: position - stream.start,
-              gen: gen,
+              gen,
               uncompressed: true
             };
           }
 
-          var contentLength = void 0,
+          let contentLength,
               startPos = position + token.length;
 
           while (startPos < buffer.length) {
-            var endPos = startPos + skipUntil(buffer, startPos, objBytes) + 4;
+            const endPos = startPos + skipUntil(buffer, startPos, objBytes) + 4;
             contentLength = endPos - position;
-            var checkPos = Math.max(endPos - CHECK_CONTENT_LENGTH, startPos);
-            var tokenStr = (0, _util.bytesToString)(buffer.subarray(checkPos, endPos));
+            const checkPos = Math.max(endPos - CHECK_CONTENT_LENGTH, startPos);
+            const tokenStr = (0, _util.bytesToString)(buffer.subarray(checkPos, endPos));
 
             if (endobjRegExp.test(tokenStr)) {
               break;
             } else {
-              var objToken = nestedObjRegExp.exec(tokenStr);
+              const objToken = nestedObjRegExp.exec(tokenStr);
 
               if (objToken && objToken[1]) {
                 (0, _util.warn)('indexObjects: Found new "obj" inside of another "obj", ' + 'caused by missing "endobj" -- trying to recover.');
@@ -1434,7 +1527,7 @@ var XRef = function XRefClosure() {
             startPos = endPos;
           }
 
-          var content = buffer.subarray(position, position + contentLength);
+          const content = buffer.subarray(position, position + contentLength);
           var xrefTagOffset = skipUntil(content, 0, xrefBytes);
 
           if (xrefTagOffset < contentLength && content[xrefTagOffset + 5] < 64) {
@@ -1443,7 +1536,7 @@ var XRef = function XRefClosure() {
           }
 
           position += contentLength;
-        } else if (token.startsWith('trailer') && (token.length === 7 || /\s/.test(token[7]))) {
+        } else if (token.startsWith("trailer") && (token.length === 7 || /\s/.test(token[7]))) {
           trailers.push(position);
           position += skipUntil(buffer, position, startxrefBytes);
         } else {
@@ -1458,40 +1551,45 @@ var XRef = function XRefClosure() {
         this.readXRef(true);
       }
 
-      var trailerDict;
+      let trailerDict;
 
       for (i = 0, ii = trailers.length; i < ii; ++i) {
         stream.pos = trailers[i];
-        var parser = new _parser.Parser(new _parser.Lexer(stream), true, this, true);
+        const parser = new _parser.Parser({
+          lexer: new _parser.Lexer(stream),
+          xref: this,
+          allowStreams: true,
+          recoveryMode: true
+        });
         var obj = parser.getObj();
 
-        if (!(0, _primitives.isCmd)(obj, 'trailer')) {
+        if (!(0, _primitives.isCmd)(obj, "trailer")) {
           continue;
         }
 
-        var dict = parser.getObj();
+        const dict = parser.getObj();
 
         if (!(0, _primitives.isDict)(dict)) {
           continue;
         }
 
-        var rootDict = void 0;
+        let rootDict;
 
         try {
-          rootDict = dict.get('Root');
+          rootDict = dict.get("Root");
         } catch (ex) {
-          if (ex instanceof _util.MissingDataException) {
+          if (ex instanceof _core_utils.MissingDataException) {
             throw ex;
           }
 
           continue;
         }
 
-        if (!(0, _primitives.isDict)(rootDict) || !rootDict.has('Pages')) {
+        if (!(0, _primitives.isDict)(rootDict) || !rootDict.has("Pages")) {
           continue;
         }
 
-        if (dict.has('ID')) {
+        if (dict.has("ID")) {
           return dict;
         }
 
@@ -1502,36 +1600,40 @@ var XRef = function XRefClosure() {
         return trailerDict;
       }
 
-      throw new _util.InvalidPDFException('Invalid PDF structure');
+      throw new _util.InvalidPDFException("Invalid PDF structure.");
     },
     readXRef: function XRef_readXRef(recoveryMode) {
       var stream = this.stream;
-      var startXRefParsedCache = Object.create(null);
+      const startXRefParsedCache = Object.create(null);
 
       try {
         while (this.startXRefQueue.length) {
           var startXRef = this.startXRefQueue[0];
 
           if (startXRefParsedCache[startXRef]) {
-            (0, _util.warn)('readXRef - skipping XRef table since it was already parsed.');
+            (0, _util.warn)("readXRef - skipping XRef table since it was already parsed.");
             this.startXRefQueue.shift();
             continue;
           }
 
           startXRefParsedCache[startXRef] = true;
           stream.pos = startXRef + stream.start;
-          var parser = new _parser.Parser(new _parser.Lexer(stream), true, this);
+          const parser = new _parser.Parser({
+            lexer: new _parser.Lexer(stream),
+            xref: this,
+            allowStreams: true
+          });
           var obj = parser.getObj();
           var dict;
 
-          if ((0, _primitives.isCmd)(obj, 'xref')) {
+          if ((0, _primitives.isCmd)(obj, "xref")) {
             dict = this.processXRefTable(parser);
 
             if (!this.topDict) {
               this.topDict = dict;
             }
 
-            obj = dict.get('XRefStm');
+            obj = dict.get("XRefStm");
 
             if (Number.isInteger(obj)) {
               var pos = obj;
@@ -1542,8 +1644,8 @@ var XRef = function XRefClosure() {
               }
             }
           } else if (Number.isInteger(obj)) {
-            if (!Number.isInteger(parser.getObj()) || !(0, _primitives.isCmd)(parser.getObj(), 'obj') || !(0, _primitives.isStream)(obj = parser.getObj())) {
-              throw new _util.FormatError('Invalid XRef stream');
+            if (!Number.isInteger(parser.getObj()) || !(0, _primitives.isCmd)(parser.getObj(), "obj") || !(0, _primitives.isStream)(obj = parser.getObj())) {
+              throw new _util.FormatError("Invalid XRef stream");
             }
 
             dict = this.processXRefStream(obj);
@@ -1553,13 +1655,13 @@ var XRef = function XRefClosure() {
             }
 
             if (!dict) {
-              throw new _util.FormatError('Failed to read XRef stream');
+              throw new _util.FormatError("Failed to read XRef stream");
             }
           } else {
-            throw new _util.FormatError('Invalid XRef stream header');
+            throw new _util.FormatError("Invalid XRef stream header");
           }
 
-          obj = dict.get('Prev');
+          obj = dict.get("Prev");
 
           if (Number.isInteger(obj)) {
             this.startXRefQueue.push(obj);
@@ -1572,18 +1674,18 @@ var XRef = function XRefClosure() {
 
         return this.topDict;
       } catch (e) {
-        if (e instanceof _util.MissingDataException) {
+        if (e instanceof _core_utils.MissingDataException) {
           throw e;
         }
 
-        (0, _util.info)('(while reading XRef): ' + e);
+        (0, _util.info)("(while reading XRef): " + e);
       }
 
       if (recoveryMode) {
-        return;
+        return undefined;
       }
 
-      throw new _util.XRefParseException();
+      throw new _core_utils.XRefParseException();
     },
     getEntry: function XRef_getEntry(i) {
       var xrefEntry = this.entries[i];
@@ -1595,22 +1697,22 @@ var XRef = function XRefClosure() {
       return null;
     },
     fetchIfRef: function XRef_fetchIfRef(obj, suppressEncryption) {
-      if (!(0, _primitives.isRef)(obj)) {
-        return obj;
+      if (obj instanceof _primitives.Ref) {
+        return this.fetch(obj, suppressEncryption);
       }
 
-      return this.fetch(obj, suppressEncryption);
+      return obj;
     },
     fetch: function XRef_fetch(ref, suppressEncryption) {
-      if (!(0, _primitives.isRef)(ref)) {
-        throw new Error('ref object is not a reference');
+      if (!(ref instanceof _primitives.Ref)) {
+        throw new Error("ref object is not a reference");
       }
 
-      var num = ref.num;
+      const num = ref.num;
 
-      if (num in this.cache) {
-        var cacheEntry = this.cache[num];
+      const cacheEntry = this._cacheMap.get(num);
 
+      if (cacheEntry !== undefined) {
         if (cacheEntry instanceof _primitives.Dict && !cacheEntry.objId) {
           cacheEntry.objId = ref.toString();
         }
@@ -1618,10 +1720,12 @@ var XRef = function XRefClosure() {
         return cacheEntry;
       }
 
-      var xrefEntry = this.getEntry(num);
+      let xrefEntry = this.getEntry(num);
 
       if (xrefEntry === null) {
-        return this.cache[num] = null;
+        this._cacheMap.set(num, xrefEntry);
+
+        return xrefEntry;
       }
 
       if (xrefEntry.uncompressed) {
@@ -1638,35 +1742,31 @@ var XRef = function XRefClosure() {
 
       return xrefEntry;
     },
-    fetchUncompressed: function fetchUncompressed(ref, xrefEntry) {
-      var suppressEncryption = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+
+    fetchUncompressed(ref, xrefEntry, suppressEncryption = false) {
       var gen = ref.gen;
       var num = ref.num;
 
       if (xrefEntry.gen !== gen) {
-        throw new _util.XRefEntryException("Inconsistent generation in XRef: ".concat(ref));
+        throw new _core_utils.XRefEntryException(`Inconsistent generation in XRef: ${ref}`);
       }
 
       var stream = this.stream.makeSubStream(xrefEntry.offset + this.stream.start);
-      var parser = new _parser.Parser(new _parser.Lexer(stream), true, this);
+      const parser = new _parser.Parser({
+        lexer: new _parser.Lexer(stream),
+        xref: this,
+        allowStreams: true
+      });
       var obj1 = parser.getObj();
       var obj2 = parser.getObj();
       var obj3 = parser.getObj();
 
-      if (!Number.isInteger(obj1)) {
-        obj1 = parseInt(obj1, 10);
+      if (obj1 !== num || obj2 !== gen || !(obj3 instanceof _primitives.Cmd)) {
+        throw new _core_utils.XRefEntryException(`Bad (uncompressed) XRef entry: ${ref}`);
       }
 
-      if (!Number.isInteger(obj2)) {
-        obj2 = parseInt(obj2, 10);
-      }
-
-      if (obj1 !== num || obj2 !== gen || !(0, _primitives.isCmd)(obj3)) {
-        throw new _util.XRefEntryException("Bad (uncompressed) XRef entry: ".concat(ref));
-      }
-
-      if (obj3.cmd !== 'obj') {
-        if (obj3.cmd.startsWith('obj')) {
+      if (obj3.cmd !== "obj") {
+        if (obj3.cmd.startsWith("obj")) {
           num = parseInt(obj3.cmd.substring(3), 10);
 
           if (!Number.isNaN(num)) {
@@ -1674,7 +1774,7 @@ var XRef = function XRefClosure() {
           }
         }
 
-        throw new _util.XRefEntryException("Bad (uncompressed) XRef entry: ".concat(ref));
+        throw new _core_utils.XRefEntryException(`Bad (uncompressed) XRef entry: ${ref}`);
       }
 
       if (this.encrypt && !suppressEncryption) {
@@ -1684,147 +1784,102 @@ var XRef = function XRefClosure() {
       }
 
       if (!(0, _primitives.isStream)(xrefEntry)) {
-        this.cache[num] = xrefEntry;
+        this._cacheMap.set(num, xrefEntry);
       }
 
       return xrefEntry;
     },
-    fetchCompressed: function fetchCompressed(ref, xrefEntry) {
-      var suppressEncryption = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-      var tableOffset = xrefEntry.offset;
-      var stream = this.fetch(new _primitives.Ref(tableOffset, 0));
+
+    fetchCompressed(ref, xrefEntry, suppressEncryption = false) {
+      const tableOffset = xrefEntry.offset;
+      const stream = this.fetch(_primitives.Ref.get(tableOffset, 0));
 
       if (!(0, _primitives.isStream)(stream)) {
-        throw new _util.FormatError('bad ObjStm stream');
+        throw new _util.FormatError("bad ObjStm stream");
       }
 
-      var first = stream.dict.get('First');
-      var n = stream.dict.get('N');
+      const first = stream.dict.get("First");
+      const n = stream.dict.get("N");
 
       if (!Number.isInteger(first) || !Number.isInteger(n)) {
-        throw new _util.FormatError('invalid first and n parameters for ObjStm stream');
+        throw new _util.FormatError("invalid first and n parameters for ObjStm stream");
       }
 
-      var parser = new _parser.Parser(new _parser.Lexer(stream), false, this);
-      parser.allowStreams = true;
-      var i,
-          entries = [],
-          num,
-          nums = [];
+      const parser = new _parser.Parser({
+        lexer: new _parser.Lexer(stream),
+        xref: this,
+        allowStreams: true
+      });
+      const nums = new Array(n);
 
-      for (i = 0; i < n; ++i) {
-        num = parser.getObj();
+      for (let i = 0; i < n; ++i) {
+        const num = parser.getObj();
 
         if (!Number.isInteger(num)) {
-          throw new _util.FormatError("invalid object number in the ObjStm stream: ".concat(num));
+          throw new _util.FormatError(`invalid object number in the ObjStm stream: ${num}`);
         }
 
-        nums.push(num);
-        var offset = parser.getObj();
+        const offset = parser.getObj();
 
         if (!Number.isInteger(offset)) {
-          throw new _util.FormatError("invalid object offset in the ObjStm stream: ".concat(offset));
+          throw new _util.FormatError(`invalid object offset in the ObjStm stream: ${offset}`);
         }
+
+        nums[i] = num;
       }
 
-      for (i = 0; i < n; ++i) {
-        entries.push(parser.getObj());
+      const entries = new Array(n);
+
+      for (let i = 0; i < n; ++i) {
+        const obj = parser.getObj();
+        entries[i] = obj;
 
-        if ((0, _primitives.isCmd)(parser.buf1, 'endobj')) {
+        if (parser.buf1 instanceof _primitives.Cmd && parser.buf1.cmd === "endobj") {
           parser.shift();
         }
 
-        num = nums[i];
-        var entry = this.entries[num];
+        if ((0, _primitives.isStream)(obj)) {
+          continue;
+        }
+
+        const num = nums[i],
+              entry = this.entries[num];
 
         if (entry && entry.offset === tableOffset && entry.gen === i) {
-          this.cache[num] = entries[i];
+          this._cacheMap.set(num, obj);
         }
       }
 
       xrefEntry = entries[xrefEntry.gen];
 
       if (xrefEntry === undefined) {
-        throw new _util.XRefEntryException("Bad (compressed) XRef entry: ".concat(ref));
+        throw new _core_utils.XRefEntryException(`Bad (compressed) XRef entry: ${ref}`);
       }
 
       return xrefEntry;
     },
-    fetchIfRefAsync: function () {
-      var _fetchIfRefAsync = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator.default.mark(function _callee(obj, suppressEncryption) {
-        return _regenerator.default.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                if ((0, _primitives.isRef)(obj)) {
-                  _context.next = 2;
-                  break;
-                }
-
-                return _context.abrupt("return", obj);
-
-              case 2:
-                return _context.abrupt("return", this.fetchAsync(obj, suppressEncryption));
-
-              case 3:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this);
-      }));
-
-      function fetchIfRefAsync(_x, _x2) {
-        return _fetchIfRefAsync.apply(this, arguments);
-      }
-
-      return fetchIfRefAsync;
-    }(),
-    fetchAsync: function () {
-      var _fetchAsync = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator.default.mark(function _callee2(ref, suppressEncryption) {
-        return _regenerator.default.wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                _context2.prev = 0;
-                return _context2.abrupt("return", this.fetch(ref, suppressEncryption));
-
-              case 4:
-                _context2.prev = 4;
-                _context2.t0 = _context2["catch"](0);
-
-                if (_context2.t0 instanceof _util.MissingDataException) {
-                  _context2.next = 8;
-                  break;
-                }
 
-                throw _context2.t0;
-
-              case 8:
-                _context2.next = 10;
-                return this.pdfManager.requestRange(_context2.t0.begin, _context2.t0.end);
+    async fetchIfRefAsync(obj, suppressEncryption) {
+      if (obj instanceof _primitives.Ref) {
+        return this.fetchAsync(obj, suppressEncryption);
+      }
 
-              case 10:
-                return _context2.abrupt("return", this.fetchAsync(ref, suppressEncryption));
+      return obj;
+    },
 
-              case 11:
-              case "end":
-                return _context2.stop();
-            }
-          }
-        }, _callee2, this, [[0, 4]]);
-      }));
+    async fetchAsync(ref, suppressEncryption) {
+      try {
+        return this.fetch(ref, suppressEncryption);
+      } catch (ex) {
+        if (!(ex instanceof _core_utils.MissingDataException)) {
+          throw ex;
+        }
 
-      function fetchAsync(_x3, _x4) {
-        return _fetchAsync.apply(this, arguments);
+        await this.pdfManager.requestRange(ex.begin, ex.end);
+        return this.fetchAsync(ref, suppressEncryption);
       }
+    },
 
-      return fetchAsync;
-    }(),
     getCatalogObj: function XRef_getCatalogObj() {
       return this.root;
     }
@@ -1834,14 +1889,10 @@ var XRef = function XRefClosure() {
 
 exports.XRef = XRef;
 
-var NameOrNumberTree =
-/*#__PURE__*/
-function () {
-  function NameOrNumberTree(root, xref, type) {
-    _classCallCheck(this, NameOrNumberTree);
-
+class NameOrNumberTree {
+  constructor(root, xref, type) {
     if (this.constructor === NameOrNumberTree) {
-      (0, _util.unreachable)('Cannot initialize NameOrNumberTree.');
+      (0, _util.unreachable)("Cannot initialize NameOrNumberTree.");
     }
 
     this.root = root;
@@ -1849,169 +1900,149 @@ function () {
     this._type = type;
   }
 
-  _createClass(NameOrNumberTree, [{
-    key: "getAll",
-    value: function getAll() {
-      var dict = Object.create(null);
-
-      if (!this.root) {
-        return dict;
-      }
+  getAll() {
+    const dict = Object.create(null);
 
-      var xref = this.xref;
-      var processed = new _primitives.RefSet();
-      processed.put(this.root);
-      var queue = [this.root];
+    if (!this.root) {
+      return dict;
+    }
 
-      while (queue.length > 0) {
-        var obj = xref.fetchIfRef(queue.shift());
+    const xref = this.xref;
+    const processed = new _primitives.RefSet();
+    processed.put(this.root);
+    const queue = [this.root];
 
-        if (!(0, _primitives.isDict)(obj)) {
-          continue;
-        }
+    while (queue.length > 0) {
+      const obj = xref.fetchIfRef(queue.shift());
 
-        if (obj.has('Kids')) {
-          var kids = obj.get('Kids');
+      if (!(0, _primitives.isDict)(obj)) {
+        continue;
+      }
 
-          for (var i = 0, ii = kids.length; i < ii; i++) {
-            var kid = kids[i];
+      if (obj.has("Kids")) {
+        const kids = obj.get("Kids");
 
-            if (processed.has(kid)) {
-              throw new _util.FormatError("Duplicate entry in \"".concat(this._type, "\" tree."));
-            }
+        for (let i = 0, ii = kids.length; i < ii; i++) {
+          const kid = kids[i];
 
-            queue.push(kid);
-            processed.put(kid);
+          if (processed.has(kid)) {
+            throw new _util.FormatError(`Duplicate entry in "${this._type}" tree.`);
           }
 
-          continue;
+          queue.push(kid);
+          processed.put(kid);
         }
 
-        var entries = obj.get(this._type);
+        continue;
+      }
 
-        if (Array.isArray(entries)) {
-          for (var _i2 = 0, _ii = entries.length; _i2 < _ii; _i2 += 2) {
-            dict[xref.fetchIfRef(entries[_i2])] = xref.fetchIfRef(entries[_i2 + 1]);
-          }
+      const entries = obj.get(this._type);
+
+      if (Array.isArray(entries)) {
+        for (let i = 0, ii = entries.length; i < ii; i += 2) {
+          dict[xref.fetchIfRef(entries[i])] = xref.fetchIfRef(entries[i + 1]);
         }
       }
-
-      return dict;
     }
-  }, {
-    key: "get",
-    value: function get(key) {
-      if (!this.root) {
-        return null;
-      }
 
-      var xref = this.xref;
-      var kidsOrEntries = xref.fetchIfRef(this.root);
-      var loopCount = 0;
-      var MAX_LEVELS = 10;
+    return dict;
+  }
 
-      while (kidsOrEntries.has('Kids')) {
-        if (++loopCount > MAX_LEVELS) {
-          (0, _util.warn)("Search depth limit reached for \"".concat(this._type, "\" tree."));
-          return null;
-        }
+  get(key) {
+    if (!this.root) {
+      return null;
+    }
 
-        var kids = kidsOrEntries.get('Kids');
+    const xref = this.xref;
+    let kidsOrEntries = xref.fetchIfRef(this.root);
+    let loopCount = 0;
+    const MAX_LEVELS = 10;
 
-        if (!Array.isArray(kids)) {
-          return null;
-        }
+    while (kidsOrEntries.has("Kids")) {
+      if (++loopCount > MAX_LEVELS) {
+        (0, _util.warn)(`Search depth limit reached for "${this._type}" tree.`);
+        return null;
+      }
 
-        var l = 0,
-            r = kids.length - 1;
+      const kids = kidsOrEntries.get("Kids");
 
-        while (l <= r) {
-          var m = l + r >> 1;
-          var kid = xref.fetchIfRef(kids[m]);
-          var limits = kid.get('Limits');
+      if (!Array.isArray(kids)) {
+        return null;
+      }
 
-          if (key < xref.fetchIfRef(limits[0])) {
-            r = m - 1;
-          } else if (key > xref.fetchIfRef(limits[1])) {
-            l = m + 1;
-          } else {
-            kidsOrEntries = xref.fetchIfRef(kids[m]);
-            break;
-          }
-        }
+      let l = 0,
+          r = kids.length - 1;
 
-        if (l > r) {
-          return null;
+      while (l <= r) {
+        const m = l + r >> 1;
+        const kid = xref.fetchIfRef(kids[m]);
+        const limits = kid.get("Limits");
+
+        if (key < xref.fetchIfRef(limits[0])) {
+          r = m - 1;
+        } else if (key > xref.fetchIfRef(limits[1])) {
+          l = m + 1;
+        } else {
+          kidsOrEntries = xref.fetchIfRef(kids[m]);
+          break;
         }
       }
 
-      var entries = kidsOrEntries.get(this._type);
+      if (l > r) {
+        return null;
+      }
+    }
 
-      if (Array.isArray(entries)) {
-        var _l = 0,
-            _r = entries.length - 2;
+    const entries = kidsOrEntries.get(this._type);
 
-        while (_l <= _r) {
-          var tmp = _l + _r >> 1,
-              _m = tmp + (tmp & 1);
+    if (Array.isArray(entries)) {
+      let l = 0,
+          r = entries.length - 2;
 
-          var currentKey = xref.fetchIfRef(entries[_m]);
+      while (l <= r) {
+        const tmp = l + r >> 1,
+              m = tmp + (tmp & 1);
+        const currentKey = xref.fetchIfRef(entries[m]);
 
-          if (key < currentKey) {
-            _r = _m - 2;
-          } else if (key > currentKey) {
-            _l = _m + 2;
-          } else {
-            return xref.fetchIfRef(entries[_m + 1]);
-          }
+        if (key < currentKey) {
+          r = m - 2;
+        } else if (key > currentKey) {
+          l = m + 2;
+        } else {
+          return xref.fetchIfRef(entries[m + 1]);
         }
+      }
 
-        (0, _util.info)("Falling back to an exhaustive search, for key \"".concat(key, "\", ") + "in \"".concat(this._type, "\" tree."));
+      (0, _util.info)(`Falling back to an exhaustive search, for key "${key}", ` + `in "${this._type}" tree.`);
 
-        for (var _m2 = 0, mm = entries.length; _m2 < mm; _m2 += 2) {
-          var _currentKey = xref.fetchIfRef(entries[_m2]);
+      for (let m = 0, mm = entries.length; m < mm; m += 2) {
+        const currentKey = xref.fetchIfRef(entries[m]);
 
-          if (_currentKey === key) {
-            (0, _util.warn)("The \"".concat(key, "\" key was found at an incorrect, ") + "i.e. out-of-order, position in \"".concat(this._type, "\" tree."));
-            return xref.fetchIfRef(entries[_m2 + 1]);
-          }
+        if (currentKey === key) {
+          (0, _util.warn)(`The "${key}" key was found at an incorrect, ` + `i.e. out-of-order, position in "${this._type}" tree.`);
+          return xref.fetchIfRef(entries[m + 1]);
         }
       }
-
-      return null;
     }
-  }]);
-
-  return NameOrNumberTree;
-}();
 
-var NameTree =
-/*#__PURE__*/
-function (_NameOrNumberTree) {
-  _inherits(NameTree, _NameOrNumberTree);
-
-  function NameTree(root, xref) {
-    _classCallCheck(this, NameTree);
-
-    return _possibleConstructorReturn(this, _getPrototypeOf(NameTree).call(this, root, xref, 'Names'));
+    return null;
   }
 
-  return NameTree;
-}(NameOrNumberTree);
+}
 
-var NumberTree =
-/*#__PURE__*/
-function (_NameOrNumberTree2) {
-  _inherits(NumberTree, _NameOrNumberTree2);
+class NameTree extends NameOrNumberTree {
+  constructor(root, xref) {
+    super(root, xref, "Names");
+  }
 
-  function NumberTree(root, xref) {
-    _classCallCheck(this, NumberTree);
+}
 
-    return _possibleConstructorReturn(this, _getPrototypeOf(NumberTree).call(this, root, xref, 'Nums'));
+class NumberTree extends NameOrNumberTree {
+  constructor(root, xref) {
+    super(root, xref, "Nums");
   }
 
-  return NumberTree;
-}(NameOrNumberTree);
+}
 
 var FileSpec = function FileSpecClosure() {
   function FileSpec(root, xref) {
@@ -2022,35 +2053,35 @@ var FileSpec = function FileSpecClosure() {
     this.xref = xref;
     this.root = root;
 
-    if (root.has('FS')) {
-      this.fs = root.get('FS');
+    if (root.has("FS")) {
+      this.fs = root.get("FS");
     }
 
-    this.description = root.has('Desc') ? (0, _util.stringToPDFString)(root.get('Desc')) : '';
+    this.description = root.has("Desc") ? (0, _util.stringToPDFString)(root.get("Desc")) : "";
 
-    if (root.has('RF')) {
-      (0, _util.warn)('Related file specifications are not supported');
+    if (root.has("RF")) {
+      (0, _util.warn)("Related file specifications are not supported");
     }
 
     this.contentAvailable = true;
 
-    if (!root.has('EF')) {
+    if (!root.has("EF")) {
       this.contentAvailable = false;
-      (0, _util.warn)('Non-embedded file specifications are not supported');
+      (0, _util.warn)("Non-embedded file specifications are not supported");
     }
   }
 
   function pickPlatformItem(dict) {
-    if (dict.has('UF')) {
-      return dict.get('UF');
-    } else if (dict.has('F')) {
-      return dict.get('F');
-    } else if (dict.has('Unix')) {
-      return dict.get('Unix');
-    } else if (dict.has('Mac')) {
-      return dict.get('Mac');
-    } else if (dict.has('DOS')) {
-      return dict.get('DOS');
+    if (dict.has("UF")) {
+      return dict.get("UF");
+    } else if (dict.has("F")) {
+      return dict.get("F");
+    } else if (dict.has("Unix")) {
+      return dict.get("Unix");
+    } else if (dict.has("Mac")) {
+      return dict.get("Mac");
+    } else if (dict.has("DOS")) {
+      return dict.get("DOS");
     }
 
     return null;
@@ -2059,8 +2090,8 @@ var FileSpec = function FileSpecClosure() {
   FileSpec.prototype = {
     get filename() {
       if (!this._filename && this.root) {
-        var filename = pickPlatformItem(this.root) || 'unnamed';
-        this._filename = (0, _util.stringToPDFString)(filename).replace(/\\\\/g, '\\').replace(/\\\//g, '/').replace(/\\/g, '/');
+        var filename = pickPlatformItem(this.root) || "unnamed";
+        this._filename = (0, _util.stringToPDFString)(filename).replace(/\\\\/g, "\\").replace(/\\\//g, "/").replace(/\\/g, "/");
       }
 
       return this._filename;
@@ -2072,7 +2103,7 @@ var FileSpec = function FileSpecClosure() {
       }
 
       if (!this.contentRef && this.root) {
-        this.contentRef = pickPlatformItem(this.root.get('EF'));
+        this.contentRef = pickPlatformItem(this.root.get("EF"));
       }
 
       var content = null;
@@ -2084,10 +2115,10 @@ var FileSpec = function FileSpecClosure() {
         if (fileObj && (0, _primitives.isStream)(fileObj)) {
           content = fileObj.getBytes();
         } else {
-          (0, _util.warn)('Embedded file specification points to non-existing/invalid ' + 'content');
+          (0, _util.warn)("Embedded file specification points to non-existing/invalid " + "content");
         }
       } else {
-        (0, _util.warn)('Embedded file specification does not have a content');
+        (0, _util.warn)("Embedded file specification does not have a content");
       }
 
       return content;
@@ -2106,26 +2137,26 @@ var FileSpec = function FileSpecClosure() {
 
 exports.FileSpec = FileSpec;
 
-var ObjectLoader = function () {
+const ObjectLoader = function () {
   function mayHaveChildren(value) {
-    return (0, _primitives.isRef)(value) || (0, _primitives.isDict)(value) || Array.isArray(value) || (0, _primitives.isStream)(value);
+    return value instanceof _primitives.Ref || value instanceof _primitives.Dict || Array.isArray(value) || (0, _primitives.isStream)(value);
   }
 
   function addChildren(node, nodesToVisit) {
-    if ((0, _primitives.isDict)(node) || (0, _primitives.isStream)(node)) {
-      var dict = (0, _primitives.isDict)(node) ? node : node.dict;
-      var dictKeys = dict.getKeys();
+    if (node instanceof _primitives.Dict || (0, _primitives.isStream)(node)) {
+      const dict = node instanceof _primitives.Dict ? node : node.dict;
+      const dictKeys = dict.getKeys();
 
-      for (var i = 0, ii = dictKeys.length; i < ii; i++) {
-        var rawValue = dict.getRaw(dictKeys[i]);
+      for (let i = 0, ii = dictKeys.length; i < ii; i++) {
+        const rawValue = dict.getRaw(dictKeys[i]);
 
         if (mayHaveChildren(rawValue)) {
           nodesToVisit.push(rawValue);
         }
       }
     } else if (Array.isArray(node)) {
-      for (var _i3 = 0, _ii2 = node.length; _i3 < _ii2; _i3++) {
-        var value = node[_i3];
+      for (let i = 0, ii = node.length; i < ii; i++) {
+        const value = node[i];
 
         if (mayHaveChildren(value)) {
           nodesToVisit.push(value);
@@ -2139,45 +2170,40 @@ var ObjectLoader = function () {
     this.keys = keys;
     this.xref = xref;
     this.refSet = null;
-    this.capability = null;
   }
 
   ObjectLoader.prototype = {
-    load: function load() {
-      this.capability = (0, _util.createPromiseCapability)();
-
-      if (!(this.xref.stream instanceof _chunked_stream.ChunkedStream) || this.xref.stream.getMissingChunks().length === 0) {
-        this.capability.resolve();
-        return this.capability.promise;
+    async load() {
+      if (!this.xref.stream.allChunksLoaded || this.xref.stream.allChunksLoaded()) {
+        return undefined;
       }
 
-      var keys = this.keys,
-          dict = this.dict;
+      const {
+        keys,
+        dict
+      } = this;
       this.refSet = new _primitives.RefSet();
-      var nodesToVisit = [];
+      const nodesToVisit = [];
 
-      for (var i = 0, ii = keys.length; i < ii; i++) {
-        var rawValue = dict.getRaw(keys[i]);
+      for (let i = 0, ii = keys.length; i < ii; i++) {
+        const rawValue = dict.getRaw(keys[i]);
 
         if (rawValue !== undefined) {
           nodesToVisit.push(rawValue);
         }
       }
 
-      this._walk(nodesToVisit);
-
-      return this.capability.promise;
+      return this._walk(nodesToVisit);
     },
-    _walk: function _walk(nodesToVisit) {
-      var _this2 = this;
 
-      var nodesToRevisit = [];
-      var pendingRequests = [];
+    async _walk(nodesToVisit) {
+      const nodesToRevisit = [];
+      const pendingRequests = [];
 
       while (nodesToVisit.length) {
-        var currentNode = nodesToVisit.pop();
+        let currentNode = nodesToVisit.pop();
 
-        if ((0, _primitives.isRef)(currentNode)) {
+        if (currentNode instanceof _primitives.Ref) {
           if (this.refSet.has(currentNode)) {
             continue;
           }
@@ -2186,7 +2212,7 @@ var ObjectLoader = function () {
             this.refSet.put(currentNode);
             currentNode = this.xref.fetch(currentNode);
           } catch (ex) {
-            if (!(ex instanceof _util.MissingDataException)) {
+            if (!(ex instanceof _core_utils.MissingDataException)) {
               throw ex;
             }
 
@@ -2199,13 +2225,13 @@ var ObjectLoader = function () {
         }
 
         if (currentNode && currentNode.getBaseStreams) {
-          var baseStreams = currentNode.getBaseStreams();
-          var foundMissingData = false;
+          const baseStreams = currentNode.getBaseStreams();
+          let foundMissingData = false;
 
-          for (var i = 0, ii = baseStreams.length; i < ii; i++) {
-            var stream = baseStreams[i];
+          for (let i = 0, ii = baseStreams.length; i < ii; i++) {
+            const stream = baseStreams[i];
 
-            if (stream.getMissingChunks && stream.getMissingChunks().length) {
+            if (stream.allChunksLoaded && !stream.allChunksLoaded()) {
               foundMissingData = true;
               pendingRequests.push({
                 begin: stream.start,
@@ -2223,23 +2249,23 @@ var ObjectLoader = function () {
       }
 
       if (pendingRequests.length) {
-        this.xref.stream.manager.requestRanges(pendingRequests).then(function () {
-          for (var _i4 = 0, _ii3 = nodesToRevisit.length; _i4 < _ii3; _i4++) {
-            var node = nodesToRevisit[_i4];
+        await this.xref.stream.manager.requestRanges(pendingRequests);
 
-            if ((0, _primitives.isRef)(node)) {
-              _this2.refSet.remove(node);
-            }
+        for (let i = 0, ii = nodesToRevisit.length; i < ii; i++) {
+          const node = nodesToRevisit[i];
+
+          if (node instanceof _primitives.Ref) {
+            this.refSet.remove(node);
           }
+        }
 
-          _this2._walk(nodesToRevisit);
-        }, this.capability.reject);
-        return;
+        return this._walk(nodesToRevisit);
       }
 
       this.refSet = null;
-      this.capability.resolve();
+      return undefined;
     }
+
   };
   return ObjectLoader;
 }();