pdfjs.parser.js

          for (var name in names) {
            if (!names.hasOwnProperty(name)) {
              continue;
            }
            // We don't really use the JavaScript right now. This code is
            // defensive so we don't cause errors on document load.
            var jsDict = names[name];
            if (isDict(jsDict)) {
              appendIfJavaScriptDict(jsDict);
            }
          }
        }

        // Append OpenAction actions to javaScript array
        var openactionDict = this.catDict.get("OpenAction");
        if (isDict(openactionDict, "Action")) {
          var actionType = openactionDict.get("S");
          if (isName(actionType) && actionType.name === "Named") {
            // The named Print action is not a part of the PDF 1.7 specification,
            // but is supported by many PDF readers/writers (including Adobe's).
            var action = openactionDict.get("N");
            if (isName(action) && action.name === "Print") {
              javaScript.push("print({});");
            }
          } else {
            appendIfJavaScriptDict(openactionDict);
          }
        }

        return shadow(this, "javaScript", javaScript);
      },

      cleanup: function Catalog_cleanup() {
        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;
            }
            this.fontCache.clear();
          }.bind(this)
        );
      },

      getPage: function Catalog_getPage(pageIndex) {
        if (!(pageIndex in this.pagePromises)) {
          this.pagePromises[pageIndex] = this.getPageDict(pageIndex).then(
            function(a) {
              var dict = a[0];
              var ref = a[1];
              return this.pageFactory.createPage(
                pageIndex,
                dict,
                ref,
                this.fontCache
              );
            }.bind(this)
          );
        }
        return this.pagePromises[pageIndex];
      },

      getPageDict: function Catalog_getPageDict(pageIndex) {
        var capability = createPromiseCapability();
        var nodesToVisit = [this.catDict.getRaw("Pages")];
        var currentPageIndex = 0;
        var xref = this.xref;
        var checkAllKids = false;

        function next() {
          while (nodesToVisit.length) {
            var currentNode = nodesToVisit.pop();

            if (isRef(currentNode)) {
              xref.fetchAsync(currentNode).then(function(obj) {
                if (isDict(obj, "Page") || (isDict(obj) && !obj.has("Kids"))) {
                  if (pageIndex === currentPageIndex) {
                    capability.resolve([obj, currentNode]);
                  } else {
                    currentPageIndex++;
                    next();
                  }
                  return;
                }
                nodesToVisit.push(obj);
                next();
              }, capability.reject);
              return;
            }

            // Must be a child page dictionary.
            assert(
              isDict(currentNode),
              "page dictionary kid reference points to wrong type of object"
            );
            var count = currentNode.get("Count");
            // If the current node doesn't have any children, avoid getting stuck
            // in an empty node further down in the tree (see issue5644.pdf).
            if (count === 0) {
              checkAllKids = true;
            }
            // Skip nodes where the page can't be.
            if (currentPageIndex + count <= pageIndex) {
              currentPageIndex += count;
              continue;
            }

            var kids = currentNode.get("Kids");
            assert(
              isArray(kids),
              "page dictionary kids object is not an array"
            );
            if (!checkAllKids && count === kids.length) {
              // Nodes that don't have the page have been skipped and this is the
              // bottom of the tree which means the page requested must be a
              // descendant of this pages node. Ideally we would just resolve the
              // promise with the page ref here, but there is the case where more
              // pages nodes could link to single a page (see issue 3666 pdf). To
              // handle this push it back on the queue so if it is a pages node it
              // will be descended into.
              nodesToVisit = [kids[pageIndex - currentPageIndex]];
              currentPageIndex = pageIndex;
              continue;
            } else {
              for (var last = kids.length - 1; last >= 0; last--) {
                nodesToVisit.push(kids[last]);
              }
            }
          }
          capability.reject("Page index " + pageIndex + " not found.");
        }
        next();
        return capability.promise;
      },

      getPageIndex: function Catalog_getPageIndex(ref) {
        // The page tree nodes have the count of all the leaves below them. To get
        // how many pages are before we just have to walk up the tree and keep
        // adding the count of siblings to the left of the node.
        var xref = this.xref;
        function pagesBeforeRef(kidRef) {
          var total = 0;
          var parentRef;
          return xref
            .fetchAsync(kidRef)
            .then(function(node) {
              if (!node) {
                return null;
              }
              parentRef = node.getRaw("Parent");
              return node.getAsync("Parent");
            })
            .then(function(parent) {
              if (!parent) {
                return null;
              }
              return parent.getAsync("Kids");
            })
            .then(function(kids) {
              if (!kids) {
                return null;
              }
              var kidPromises = [];
              var found = false;
              for (var i = 0; i < kids.length; i++) {
                var kid = kids[i];
                assert(isRef(kid), "kids must be a ref");
                if (kid.num === kidRef.num) {
                  found = true;
                  break;
                }
                kidPromises.push(
                  xref.fetchAsync(kid).then(function(kid) {
                    if (kid.has("Count")) {
                      var count = kid.get("Count");
                      total += count;
                    } else {
                      // page leaf node
                      total++;
                    }
                  })
                );
              }
              if (!found) {
                error("kid ref not found in parents kids");
              }
              return Promise.all(kidPromises).then(function() {
                return [total, parentRef];
              });
            });
        }

        var total = 0;
        function next(ref) {
          return pagesBeforeRef(ref).then(function(args) {
            if (!args) {
              return total;
            }
            var count = args[0];
            var parentRef = args[1];
            total += count;
            return next(parentRef);
          });
        }

        return next(ref);
      }
    };

    return Catalog;
  })();

  var XRef = (function XRefClosure() {
    function XRef(stream, password) {
      this.stream = stream;
      this.entries = [];
      this.xrefstms = {};
      // prepare the XRef cache
      this.cache = [];
      this.password = password;
      this.stats = {
        streamTypes: [],
        fontTypes: []
      };
    }

    XRef.prototype = {
      setStartXRef: function XRef_setStartXRef(startXRef) {
        // Store the starting positions of xref tables as we process them
        // so we can recover from missing data errors
        this.startXRefQueue = [startXRef];
        this.xrefBlocks = [startXRef];
      },

      parse: function XRef_parse(recoveryMode) {
        var trailerDict;
        if (!recoveryMode) {
          trailerDict = this.readXRef();
        } else {
          warn("Indexing all PDF objects");
          trailerDict = this.indexObjects();
        }
        trailerDict.assignXref(this);
        this.trailer = trailerDict;
        var encrypt = trailerDict.get("Encrypt");
        if (encrypt) {
          var ids = trailerDict.get("ID");
          var fileId = ids && ids.length ? ids[0] : "";
          this.encrypt = new CipherTransformFactory(
            encrypt,
            fileId,
            this.password
          );
        }

        // get the root dictionary (catalog) object
        if (!(this.root = trailerDict.get("Root"))) {
          error("Invalid root reference");
        }
      },

      processXRefTable: function XRef_processXRefTable(parser) {
        if (!("tableState" in this)) {
          // Stores state of the table as we process it so we can resume
          // from middle of table in case of missing data error
          this.tableState = {
            entryNum: 0,
            streamPos: parser.lexer.stream.pos,
            parserBuf1: parser.buf1,
            parserBuf2: parser.buf2
          };
        }

        var obj = this.readXRefTable(parser);

        // Sanity check
        if (!isCmd(obj, "trailer")) {
          error("Invalid XRef table: could not find trailer dictionary");
        }
        // Read trailer dictionary, e.g.
        // trailer
        //    << /Size 22
        //      /Root 20R
        //      /Info 10R
        //      /ID [ <81b14aafa313db63dbd6f981e49f94f4> ]
        //    >>
        // The parser goes through the entire stream << ... >> and provides
        // a getter interface for the key-value table
        var dict = parser.getObj();

        // The pdflib PDF generator can generate a nested trailer dictionary
        if (!isDict(dict) && dict.dict) {
          dict = dict.dict;
        }
        if (!isDict(dict)) {
          error("Invalid XRef table: could not parse trailer dictionary");
        }
        delete this.tableState;

        return dict;
      },

      readXRefTable: function XRef_readXRefTable(parser) {
        // Example of cross-reference table:
        // xref
        // 0 1                    <-- subsection header (first obj #, obj count)
        // 0000000000 65535 f     <-- actual object (offset, generation #, f/n)
        // 23 2                   <-- subsection header ... and so on ...
        // 0000025518 00002 n
        // 0000025635 00000 n
        // trailer
        // ...

        var stream = parser.lexer.stream;
        var tableState = this.tableState;
        stream.pos = tableState.streamPos;
        parser.buf1 = tableState.parserBuf1;
        parser.buf2 = tableState.parserBuf2;

        // Outer loop is over subsection headers
        var obj;

        while (true) {
          if (
            !("firstEntryNum" in tableState) ||
            !("entryCount" in tableState)
          ) {
            if (isCmd((obj = parser.getObj()), "trailer")) {
              break;
            }
            tableState.firstEntryNum = obj;
            tableState.entryCount = parser.getObj();
          }

          var first = tableState.firstEntryNum;
          var count = tableState.entryCount;
          if (!isInt(first) || !isInt(count)) {
            error("Invalid XRef table: wrong types in subsection header");
          }
          // Inner loop is over objects themselves
          for (var i = tableState.entryNum; i < count; i++) {
            tableState.streamPos = stream.pos;
            tableState.entryNum = i;
            tableState.parserBuf1 = parser.buf1;
            tableState.parserBuf2 = parser.buf2;

            var entry = {};
            entry.offset = parser.getObj();
            entry.gen = parser.getObj();
            var type = parser.getObj();

            if (isCmd(type, "f")) {
              entry.free = true;
            } else if (isCmd(type, "n")) {
              entry.uncompressed = true;
            }

            // Validate entry obj
            if (
              !isInt(entry.offset) ||
              !isInt(entry.gen) ||
              !(entry.free || entry.uncompressed)
            ) {
              error(
                "Invalid entry in XRef subsection: " + first + ", " + count
              );
            }

            if (!this.entries[i + first]) {
              this.entries[i + first] = entry;
            }
          }

          tableState.entryNum = 0;
          tableState.streamPos = stream.pos;
          tableState.parserBuf1 = parser.buf1;
          tableState.parserBuf2 = parser.buf2;
          delete tableState.firstEntryNum;
          delete tableState.entryCount;
        }

        // Per issue 3248: hp scanners generate bad XRef
        if (first === 1 && this.entries[1] && this.entries[1].free) {
          // shifting the entries
          this.entries.shift();
        }

        // Sanity check: as per spec, first object must be free
        if (this.entries[0] && !this.entries[0].free) {
          error("Invalid XRef table: unexpected first object");
        }
        return obj;
      },

      processXRefStream: function XRef_processXRefStream(stream) {
        if (!("streamState" in this)) {
          // Stores state of the stream as we process it so we can resume
          // from middle of stream in case of missing data error
          var streamParameters = stream.dict;
          var byteWidths = streamParameters.get("W");
          var range = streamParameters.get("Index");
          if (!range) {
            range = [0, streamParameters.get("Size")];
          }

          this.streamState = {
            entryRanges: range,
            byteWidths: byteWidths,
            entryNum: 0,
            streamPos: stream.pos
          };
        }
        this.readXRefStream(stream);
        delete this.streamState;

        return stream.dict;
      },

      readXRefStream: function XRef_readXRefStream(stream) {
        var i, j;
        var streamState = this.streamState;
        stream.pos = streamState.streamPos;

        var byteWidths = streamState.byteWidths;
        var typeFieldWidth = byteWidths[0];
        var offsetFieldWidth = byteWidths[1];
        var generationFieldWidth = byteWidths[2];

        var entryRanges = streamState.entryRanges;
        while (entryRanges.length > 0) {
          var first = entryRanges[0];
          var n = entryRanges[1];

          if (!isInt(first) || !isInt(n)) {
            error("Invalid XRef range fields: " + first + ", " + n);
          }
          if (
            !isInt(typeFieldWidth) ||
            !isInt(offsetFieldWidth) ||
            !isInt(generationFieldWidth)
          ) {
            error("Invalid XRef entry fields length: " + first + ", " + n);
          }
          for (i = streamState.entryNum; i < n; ++i) {
            streamState.entryNum = i;
            streamState.streamPos = stream.pos;

            var type = 0,
              offset = 0,
              generation = 0;
            for (j = 0; j < typeFieldWidth; ++j) {
              type = (type << 8) | stream.getByte();
            }
            // if type field is absent, its default value is 1
            if (typeFieldWidth === 0) {
              type = 1;
            }
            for (j = 0; j < offsetFieldWidth; ++j) {
              offset = (offset << 8) | stream.getByte();
            }
            for (j = 0; j < generationFieldWidth; ++j) {
              generation = (generation << 8) | stream.getByte();
            }
            var entry = {};
            entry.offset = offset;
            entry.gen = generation;
            switch (type) {
              case 0:
                entry.free = true;
                break;
              case 1:
                entry.uncompressed = true;
                break;
              case 2:
                break;
              default:
                error("Invalid XRef entry type: " + type);
            }
            if (!this.entries[first + i]) {
              this.entries[first + i] = entry;
            }
          }

          streamState.entryNum = 0;
          streamState.streamPos = stream.pos;
          entryRanges.splice(0, 2);
        }
      },

      indexObjects: function XRef_indexObjects() {
        // Simple scan through the PDF content to find objects,
        // trailers and XRef streams.
        var TAB = 0x9,
          LF = 0xa,
          CR = 0xd,
          SPACE = 0x20;
        var PERCENT = 0x25,
          LT = 0x3c;

        function readToken(data, offset) {
          var token = "",
            ch = data[offset];
          while (ch !== LF && ch !== CR && ch !== LT) {
            if (++offset >= data.length) {
              break;
            }
            token += String.fromCharCode(ch);
            ch = data[offset];
          }
          return token;
        }
        function skipUntil(data, offset, what) {
          var length = what.length,
            dataLength = data.length;
          var skipped = 0;
          // finding byte sequence
          while (offset < dataLength) {
            var i = 0;
            while (i < length && data[offset + i] === what[i]) {
              ++i;
            }
            if (i >= length) {
              break; // sequence found
            }
            offset++;
            skipped++;
          }
          return skipped;
        }
        var objRegExp = /^(\d+)\s+(\d+)\s+obj\b/;
        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 endobjBytes = new Uint8Array([101, 110, 100, 111, 98, 106]);
        var xrefBytes = new Uint8Array([47, 88, 82, 101, 102]);

        // Clear out any existing entries, since they may be bogus.
        this.entries.length = 0;

        var stream = this.stream;
        stream.pos = 0;
        var buffer = stream.getBytes();
        var position = stream.start,
          length = buffer.length;
        var trailers = [],
          xrefStms = [];
        while (position < length) {
          var ch = buffer[position];
          if (ch === TAB || ch === LF || ch === CR || ch === SPACE) {
            ++position;
            continue;
          }
          if (ch === PERCENT) {
            // %-comment
            do {
              ++position;
              if (position >= length) {
                break;
              }
              ch = buffer[position];
            } while (ch !== LF && ch !== CR);
            continue;
          }
          var token = readToken(buffer, position);
          var m;
          if (
            token.indexOf("xref") === 0 &&
            (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))) {
            if (typeof this.entries[m[1]] === "undefined") {
              this.entries[m[1]] = {
                offset: position - stream.start,
                gen: m[2] | 0,
                uncompressed: true
              };
            }
            var contentLength = skipUntil(buffer, position, endobjBytes) + 7;
            var content = buffer.subarray(position, position + contentLength);

            // checking XRef stream suspect
            // (it shall have '/XRef' and next char is not a letter)
            var xrefTagOffset = skipUntil(content, 0, xrefBytes);
            if (
              xrefTagOffset < contentLength &&
              content[xrefTagOffset + 5] < 64
            ) {
              xrefStms.push(position - stream.start);
              this.xrefstms[position - stream.start] = 1; // Avoid recursion
            }

            position += contentLength;
          } else if (
            token.indexOf("trailer") === 0 &&
            (token.length === 7 || /\s/.test(token[7]))
          ) {
            trailers.push(position);
            position += skipUntil(buffer, position, startxrefBytes);
          } else {
            position += token.length + 1;
          }
        }
        // reading XRef streams
        var i, ii;
        for (i = 0, ii = xrefStms.length; i < ii; ++i) {
          this.startXRefQueue.push(xrefStms[i]);
          this.xrefBlocks.push(xrefStms[i]);
          this.readXRef(/* recoveryMode */ true);
        }
        // finding main trailer
        var dict;
        for (i = 0, ii = trailers.length; i < ii; ++i) {
          stream.pos = trailers[i];
          var parser = new Parser(new Lexer(stream), true, this);
          var obj = parser.getObj();
          if (!isCmd(obj, "trailer")) {
            continue;
          }
          // read the trailer dictionary
          if (!isDict((dict = parser.getObj()))) {
            continue;
          }
          // taking the first one with 'ID'
          if (dict.has("ID")) {
            return dict;
          }
        }
        // no tailer with 'ID', taking last one (if exists)
        if (dict) {
          return dict;
        }
        // nothing helps
        // calling error() would reject worker with an UnknownErrorException.
        throw new InvalidPDFException("Invalid PDF structure");
      },

      readXRef: function XRef_readXRef(recoveryMode) {
        var stream = this.stream;

        try {
          while (this.startXRefQueue.length) {
            var startXRef = this.startXRefQueue[0];

            stream.pos = startXRef + stream.start;

            var parser = new Parser(new Lexer(stream), true, this);
            var obj = parser.getObj();
            var dict;

            // Get dictionary
            if (isCmd(obj, "xref")) {
              // Parse end-of-file XRef
              dict = this.processXRefTable(parser);
              if (!this.topDict) {
                this.topDict = dict;
              }

              // Recursively get other XRefs 'XRefStm', if any
              obj = dict.get("XRefStm");
              if (isInt(obj)) {
                var pos = obj;
                // ignore previously loaded xref streams
                // (possible infinite recursion)
                if (!(pos in this.xrefstms)) {
                  this.xrefstms[pos] = 1;
                  this.startXRefQueue.push(pos);
                  this.xrefBlocks.push(pos);
                }
              }
            } else if (isInt(obj)) {
              // Parse in-stream XRef
              if (
                !isInt(parser.getObj()) ||
                !isCmd(parser.getObj(), "obj") ||
                !isStream((obj = parser.getObj()))
              ) {
                error("Invalid XRef stream");
              }
              dict = this.processXRefStream(obj);
              if (!this.topDict) {
                this.topDict = dict;
              }
              if (!dict) {
                error("Failed to read XRef stream");
              }
            } else {
              error("Invalid XRef stream header");
            }

            // Recursively get previous dictionary, if any
            obj = dict.get("Prev");
            if (isInt(obj)) {
              this.startXRefQueue.push(obj);
              this.xrefBlocks.push(obj);
            } else if (isRef(obj)) {
              // The spec says Prev must not be a reference, i.e. "/Prev NNN"
              // This is a fallback for non-compliant PDFs, i.e. "/Prev NNN 0 R"
              this.startXRefQueue.push(obj.num);
              this.xrefBlocks.push(obj.num);
            }
            this.xrefBlocks.push(stream.pos);
            this.startXRefQueue.shift();
          }

          return this.topDict;
        } catch (e) {
          if (e instanceof MissingDataException) {
            throw e;
          }
          info("(while reading XRef): " + e);
        }

        if (recoveryMode) {
          return;
        }
        throw new XRefParseException();
      },

      getEntry: function XRef_getEntry(i) {
        var xrefEntry = this.entries[i];
        if (xrefEntry && !xrefEntry.free && xrefEntry.offset) {
          return xrefEntry;
        }
        return null;
      },

      fetchIfRef: function XRef_fetchIfRef(obj) {
        if (!isRef(obj)) {
          return obj;
        }
        return this.fetch(obj);
      },

      fetch: function XRef_fetch(ref, suppressEncryption) {
        assert(isRef(ref), "ref object is not a reference");
        var num = ref.num;
        if (num in this.cache) {
          var cacheEntry = this.cache[num];
          return cacheEntry;
        }

        var xrefEntry = this.getEntry(num);

        // the referenced entry can be free
        if (xrefEntry === null) {
          return (this.cache[num] = null);
        }

        if (xrefEntry.uncompressed) {
          xrefEntry = this.fetchUncompressed(
            ref,
            xrefEntry,
            suppressEncryption
          );
        } else {
          xrefEntry = this.fetchCompressed(xrefEntry, suppressEncryption);
        }
        if (isDict(xrefEntry)) {
          xrefEntry.objId = ref.toString();
        } else if (isStream(xrefEntry)) {
          xrefEntry.dict.objId = ref.toString();
        }
        return xrefEntry;
      },

      fetchUncompressed: function XRef_fetchUncompressed(
        ref,
        xrefEntry,
        suppressEncryption
      ) {
        var gen = ref.gen;
        var num = ref.num;
        if (xrefEntry.gen !== gen) {
          error("inconsistent generation in XRef");
        }
        var stream = this.stream.makeSubStream(
          xrefEntry.offset + this.stream.start
        );
        var parser = new Parser(new Lexer(stream), true, this);
        var obj1 = parser.getObj();
        var obj2 = parser.getObj();
        var obj3 = parser.getObj();
        if (
          !isInt(obj1) ||
          parseInt(obj1, 10) !== num ||
          !isInt(obj2) ||
          parseInt(obj2, 10) !== gen ||
          !isCmd(obj3)
        ) {
          error("bad XRef entry");
        }
        if (!isCmd(obj3, "obj")) {
          // some bad PDFs use "obj1234" and really mean 1234
          if (obj3.cmd.indexOf("obj") === 0) {
            num = parseInt(obj3.cmd.substring(3), 10);
            if (!isNaN(num)) {
              return num;
            }
          }
          error("bad XRef entry");
        }
        if (this.encrypt && !suppressEncryption) {
          xrefEntry = parser.getObj(
            this.encrypt.createCipherTransform(num, gen)
          );
        } else {
          xrefEntry = parser.getObj();
        }
        if (!isStream(xrefEntry)) {
          this.cache[num] = xrefEntry;
        }
        return xrefEntry;
      },

      fetchCompressed: function XRef_fetchCompressed(
        xrefEntry,
        suppressEncryption
      ) {
        var tableOffset = xrefEntry.offset;
        var stream = this.fetch(new Ref(tableOffset, 0));
        if (!isStream(stream)) {
          error("bad ObjStm stream");
        }
        var first = stream.dict.get("First");
        var n = stream.dict.get("N");
        if (!isInt(first) || !isInt(n)) {
          error("invalid first and n parameters for ObjStm stream");
        }
        var parser = new Parser(new Lexer(stream), false, this);
        parser.allowStreams = true;
        var i,
          entries = [],
          num,
          nums = [];
        // read the object numbers to populate cache
        for (i = 0; i < n; ++i) {
          num = parser.getObj();
          if (!isInt(num)) {
            error("invalid object number in the ObjStm stream: " + num);
          }
          nums.push(num);
          var offset = parser.getObj();
          if (!isInt(offset)) {
            error("invalid object offset in the ObjStm stream: " + offset);
          }
        }
        // read stream objects for cache
        for (i = 0; i < n; ++i) {
          entries.push(parser.getObj());
          num = nums[i];
          var entry = this.entries[num];
          if (entry && entry.offset === tableOffset && entry.gen === i) {
            this.cache[num] = entries[i];
          }
        }
        xrefEntry = entries[xrefEntry.gen];
        if (xrefEntry === undefined) {
          error("bad XRef entry for compressed object");
        }
        return xrefEntry;
      },

      fetchIfRefAsync: function XRef_fetchIfRefAsync(obj) {
        if (!isRef(obj)) {
          return Promise.resolve(obj);
        }
        return this.fetchAsync(obj);
      },

      fetchAsync: function XRef_fetchAsync(ref, suppressEncryption) {
        var streamManager = this.stream.manager;
        var xref = this;
        return new Promise(function tryFetch(resolve, reject) {
          try {
            resolve(xref.fetch(ref, suppressEncryption));
          } catch (e) {
            if (e instanceof MissingDataException) {
              streamManager.requestRange(e.begin, e.end).then(function() {
                tryFetch(resolve, reject);
              }, reject);
              return;
            }
            reject(e);
          }
        });
      },

      getCatalogObj: function XRef_getCatalogObj() {
        return this.root;
      }
    };

    return XRef;
  })();

  /**
   * A NameTree is like a Dict but has some advantageous properties, see the
   * spec (7.9.6) for more details.
   * TODO: implement all the Dict functions and make this more efficent.
   */
  var NameTree = (function NameTreeClosure() {
    function NameTree(root, xref) {
      this.root = root;
      this.xref = xref;
    }

    NameTree.prototype = {
      getAll: function NameTree_getAll() {
        var dict = {};
        if (!this.root) {
          return dict;
        }
        var xref = this.xref;
        // reading name tree
        var processed = new RefSet();
        processed.put(this.root);
        var queue = [this.root];
        while (queue.length > 0) {
          var i, n;
          var obj = xref.fetchIfRef(queue.shift());
          if (!isDict(obj)) {
            continue;
          }
          if (obj.has("Kids")) {
            var kids = obj.get("Kids");
            for (i = 0, n = kids.length; i < n; i++) {
              var kid = kids[i];
              if (processed.has(kid)) {
                error("invalid destinations");
              }
              queue.push(kid);
              processed.put(kid);
            }
            continue;
          }
          var names = obj.get("Names");
          if (names) {
            for (i = 0, n = names.length; i < n; i += 2) {
              dict[xref.fetchIfRef(names[i])] = xref.fetchIfRef(names[i + 1]);
            }
          }
        }
        return dict;
      },

      get: function NameTree_get(destinationId) {
        if (!this.root) {
          return null;
        }

        var xref = this.xref;
        var kidsOrNames = xref.fetchIfRef(this.root);
        var loopCount = 0;
        var MAX_NAMES_LEVELS = 10;
        var l, r, m;

        // Perform a binary search to quickly find the entry that
        // contains the named destination we are looking for.
        while (kidsOrNames.has("Kids")) {
          loopCount++;
          if (loopCount > MAX_NAMES_LEVELS) {
            warn(
              "Search depth limit for named destionations has been reached."
            );
            return null;
          }

          var kids = kidsOrNames.get("Kids");
          if (!isArray(kids)) {
            return null;
          }

          l = 0;
          r = kids.length - 1;
          while (l <= r) {
            m = (l + r) >> 1;
            var kid = xref.fetchIfRef(kids[m]);
            var limits = kid.get("Limits");

            if (destinationId < xref.fetchIfRef(limits[0])) {
              r = m - 1;
            } else if (destinationId > xref.fetchIfRef(limits[1])) {
              l = m + 1;
            } else {