text: /* Copyright 2012 Mozilla Foundation
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  'use strict';
  
  (function (root, factory) {
    if (typeof define === 'function' && define.amd) {
      define('pdfjs/core/obj', ['exports', 'pdfjs/shared/util',
        'pdfjs/core/primitives', 'pdfjs/core/crypto', 'pdfjs/core/parser',
        'pdfjs/core/chunked_stream'], factory);
    } else if (typeof exports !== 'undefined') {
      factory(exports, require('../shared/util.js'), require('./primitives.js'),
        require('./crypto.js'), require('./parser.js'),
        require('./chunked_stream.js'));
    } else {
      factory((root.pdfjsCoreObj = {}), root.pdfjsSharedUtil,
        root.pdfjsCorePrimitives, root.pdfjsCoreCrypto, root.pdfjsCoreParser,
        root.pdfjsCoreChunkedStream);
    }
  }(this, function (exports, sharedUtil, corePrimitives, coreCrypto, coreParser,
                    coreChunkedStream) {
  
  var InvalidPDFException = sharedUtil.InvalidPDFException;
  var MissingDataException = sharedUtil.MissingDataException;
  var XRefParseException = sharedUtil.XRefParseException;
  var assert = sharedUtil.assert;
  var bytesToString = sharedUtil.bytesToString;
  var createPromiseCapability = sharedUtil.createPromiseCapability;
  var error = sharedUtil.error;
  var info = sharedUtil.info;
  var isArray = sharedUtil.isArray;
  var isInt = sharedUtil.isInt;
  var isString = sharedUtil.isString;
  var shadow = sharedUtil.shadow;
  var stringToPDFString = sharedUtil.stringToPDFString;
  var stringToUTF8String = sharedUtil.stringToUTF8String;
  var warn = sharedUtil.warn;
  var Ref = corePrimitives.Ref;
  var RefSet = corePrimitives.RefSet;
  var RefSetCache = corePrimitives.RefSetCache;
  var isName = corePrimitives.isName;
  var isCmd = corePrimitives.isCmd;
  var isDict = corePrimitives.isDict;
  var isRef = corePrimitives.isRef;
  var isStream = corePrimitives.isStream;
  var CipherTransformFactory = coreCrypto.CipherTransformFactory;
  var Lexer = coreParser.Lexer;
  var Parser = coreParser.Parser;
  var ChunkedStream = coreChunkedStream.ChunkedStream;
  
  var Catalog = (function CatalogClosure() {
    function Catalog(pdfManager, xref, pageFactory) {
      this.pdfManager = pdfManager;
      this.xref = xref;
      this.catDict = xref.getCatalogObj();
      this.fontCache = new RefSetCache();
      assert(isDict(this.catDict),
        'catalog object is not a dictionary');
  
      // TODO refactor to move getPage() to the PDFDocument.
      this.pageFactory = pageFactory;
      this.pagePromises = [];
    }
  
    Catalog.prototype = {
      get metadata() {
        var streamRef = this.catDict.getRaw('Metadata');
        if (!isRef(streamRef)) {
          return shadow(this, 'metadata', null);
        }
  
        var encryptMetadata = (!this.xref.encrypt ? false :
                               this.xref.encrypt.encryptMetadata);
  
        var stream = this.xref.fetch(streamRef, !encryptMetadata);
        var metadata;
        if (stream && isDict(stream.dict)) {
          var type = stream.dict.get('Type');
          var subtype = stream.dict.get('Subtype');
  
          if (isName(type) && isName(subtype) &&
              type.name === 'Metadata' && subtype.name === 'XML') {
            // XXX: This should examine the charset the XML document defines,
            // however since there are currently no real means to decode
            // arbitrary charsets, let's just hope that the author of the PDF
            // was reasonable enough to stick with the XML default charset,
            // which is UTF-8.
            try {
              metadata = stringToUTF8String(bytesToString(stream.getBytes()));
            } catch (e) {
              info('Skipping invalid metadata.');
            }
          }
        }
  
        return shadow(this, 'metadata', metadata);
      },
      get toplevelPagesDict() {
        var pagesObj = this.catDict.get('Pages');
        assert(isDict(pagesObj), 'invalid top-level pages dictionary');
        // shadow the prototype getter
        return shadow(this, 'toplevelPagesDict', pagesObj);
      },
      get documentOutline() {
        var obj = null;
        try {
          obj = this.readDocumentOutline();
        } catch (ex) {
          if (ex instanceof MissingDataException) {
            throw ex;
          }
          warn('Unable to read document outline');
        }
        return shadow(this, 'documentOutline', obj);
      },
      readDocumentOutline: function Catalog_readDocumentOutline() {
        var xref = this.xref;
        var obj = this.catDict.get('Outlines');
        var root = { items: [] };
        if (isDict(obj)) {
          obj = obj.getRaw('First');
          var processed = new RefSet();
          if (isRef(obj)) {
            var queue = [{obj: obj, parent: root}];
            // to avoid recursion keeping track of the items
            // in the processed dictionary
            processed.put(obj);
            while (queue.length > 0) {
              var i = queue.shift();
              var outlineDict = xref.fetchIfRef(i.obj);
              if (outlineDict === null) {
                continue;
              }
              if (!outlineDict.has('Title')) {
                error('Invalid outline item');
              }
              var dest = outlineDict.get('A');
              if (dest) {
                dest = dest.get('D');
              } else if (outlineDict.has('Dest')) {
                dest = outlineDict.getRaw('Dest');
                if (isName(dest)) {
                  dest = dest.name;
                }
              }
              var title = outlineDict.get('Title');
              var outlineItem = {
                dest: dest,
                title: stringToPDFString(title),
                color: outlineDict.get('C') || [0, 0, 0],
                count: outlineDict.get('Count'),
                bold: !!(outlineDict.get('F') & 2),
                italic: !!(outlineDict.get('F') & 1),
                items: []
              };
              i.parent.items.push(outlineItem);
              obj = outlineDict.getRaw('First');
              if (isRef(obj) && !processed.has(obj)) {
                queue.push({obj: obj, parent: outlineItem});
                processed.put(obj);
              }
              obj = outlineDict.getRaw('Next');
              if (isRef(obj) && !processed.has(obj)) {
                queue.push({obj: obj, parent: i.parent});
                processed.put(obj);
              }
            }
          }
        }
        return (root.items.length > 0 ? root.items : null);
      },
      get numPages() {
        var obj = this.toplevelPagesDict.get('Count');
        assert(
          isInt(obj),
          'page count in top level pages object is not an integer'
        );
        // shadow the prototype getter
        return shadow(this, 'num', obj);
      },
      get destinations() {
        function fetchDestination(dest) {
          return isDict(dest) ? dest.get('D') : dest;
        }
  
        var xref = this.xref;
        var dests = {}, nameTreeRef, nameDictionaryRef;
        var obj = this.catDict.get('Names');
        if (obj && obj.has('Dests')) {
          nameTreeRef = obj.getRaw('Dests');
        } else if (this.catDict.has('Dests')) {
          nameDictionaryRef = this.catDict.get('Dests');
        }
  
        if (nameDictionaryRef) {
          // reading simple destination dictionary
          obj = nameDictionaryRef;
          obj.forEach(function catalogForEach(key, value) {
            if (!value) {
              return;
            }
            dests[key] = fetchDestination(value);
          });
        }
        if (nameTreeRef) {
          var nameTree = new NameTree(nameTreeRef, xref);
          var names = nameTree.getAll();
          for (var name in names) {
            if (!names.hasOwnProperty(name)) {
              continue;
            }
            dests[name] = fetchDestination(names[name]);
          }
        }
        return shadow(this, 'destinations', dests);
      },
      getDestination: function Catalog_getDestination(destinationId) {
        function fetchDestination(dest) {
          return isDict(dest) ? dest.get('D') : dest;
        }
  
        var xref = this.xref;
        var dest = null, nameTreeRef, nameDictionaryRef;
        var obj = this.catDict.get('Names');
        if (obj && obj.has('Dests')) {
          nameTreeRef = obj.getRaw('Dests');
        } else if (this.catDict.has('Dests')) {
          nameDictionaryRef = this.catDict.get('Dests');
        }
  
        if (nameDictionaryRef) { // Simple destination dictionary.
          var value = nameDictionaryRef.get(destinationId);
          if (value) {
            dest = fetchDestination(value);
          }
        }
        if (nameTreeRef) {
          var nameTree = new NameTree(nameTreeRef, xref);
          dest = fetchDestination(nameTree.get(destinationId));
        }
        return dest;
      },
      get attachments() {
        var xref = this.xref;
        var attachments = null, nameTreeRef;
        var obj = this.catDict.get('Names');
        if (obj) {
          nameTreeRef = obj.getRaw('EmbeddedFiles');
        }
  
        if (nameTreeRef) {
          var nameTree = new NameTree(nameTreeRef, xref);
          var names = nameTree.getAll();
          for (var name in names) {
            if (!names.hasOwnProperty(name)) {
              continue;
            }
            var fs = new FileSpec(names[name], xref);
            if (!attachments) {
              attachments = {};
            }
            attachments[stringToPDFString(name)] = fs.serializable;
          }
        }
        return shadow(this, 'attachments', attachments);
      },
      get javaScript() {
        var xref = this.xref;
        var obj = this.catDict.get('Names');
  
        var javaScript = [];
        function appendIfJavaScriptDict(jsDict) {
          var type = jsDict.get('S');
          if (!isName(type) || type.name !== 'JavaScript') {
            return;
          }
          var js = jsDict.get('JS');
          if (isStream(js)) {
            js = bytesToString(js.getBytes());
          } else if (!isString(js)) {
            return;
          }
          javaScript.push(stringToPDFString(js));
        }
        if (obj && obj.has('JavaScript')) {
          var nameTree = new NameTree(obj.getRaw('JavaScript'), xref);
          var names = nameTree.getAll();
          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];
      },
  
      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.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);
                }
              }
            } 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);
            } 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.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 {
              kidsOrNames = xref.fetchIfRef(kids[m]);
              break;
            }
          }
          if (l > r) {
            return null;
          }
        }
  
        // If we get here, then we have found the right entry. Now
        // go through the named destinations in the Named dictionary
        // until we find the exact destination we're looking for.
        var names = kidsOrNames.get('Names');
        if (isArray(names)) {
          // Perform a binary search to reduce the lookup time.
          l = 0;
          r = names.length - 2;
          while (l <= r) {
            // Check only even indices (0, 2, 4, ...) because the
            // odd indices contain the actual D array.
            m = (l + r) & ~1;
            if (destinationId < xref.fetchIfRef(names[m])) {
              r = m - 2;
            } else if (destinationId > xref.fetchIfRef(names[m])) {
              l = m + 2;
            } else {
              return xref.fetchIfRef(names[m + 1]);
            }
          }
        }
        return null;
      }
    };
    return NameTree;
  })();
  
  /**
   * "A PDF file can refer to the contents of another file by using a File
   * Specification (PDF 1.1)", see the spec (7.11) for more details.
   * NOTE: Only embedded files are supported (as part of the attachments support)
   * TODO: support the 'URL' file system (with caching if !/V), portable
   * collections attributes and related files (/RF)
   */
  var FileSpec = (function FileSpecClosure() {
    function FileSpec(root, xref) {
      if (!root || !isDict(root)) {
        return;
      }
      this.xref = xref;
      this.root = root;
      if (root.has('FS')) {
        this.fs = root.get('FS');
      }
      this.description = root.has('Desc') ?
                           stringToPDFString(root.get('Desc')) :
                           '';
      if (root.has('RF')) {
        warn('Related file specifications are not supported');
      }
      this.contentAvailable = true;
      if (!root.has('EF')) {
        this.contentAvailable = false;
        warn('Non-embedded file specifications are not supported');
      }
    }
  
    function pickPlatformItem(dict) {
      // Look for the filename in this order:
      // UF, F, Unix, Mac, 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');
      } else {
        return null;
      }
    }
  
    FileSpec.prototype = {
      get filename() {
        if (!this._filename && this.root) {
          var filename = pickPlatformItem(this.root) || 'unnamed';
          this._filename = stringToPDFString(filename).
            replace(/\\\\/g, '\\').
            replace(/\\\//g, '/').
            replace(/\\/g, '/');
        }
        return this._filename;
      },
      get content() {
        if (!this.contentAvailable) {
          return null;
        }
        if (!this.contentRef && this.root) {
          this.contentRef = pickPlatformItem(this.root.get('EF'));
        }
        var content = null;
        if (this.contentRef) {
          var xref = this.xref;
          var fileObj = xref.fetchIfRef(this.contentRef);
          if (fileObj && isStream(fileObj)) {
            content = fileObj.getBytes();
          } else {
            warn('Embedded file specification points to non-existing/invalid ' +
              'content');
          }
        } else {
          warn('Embedded file specification does not have a content');
        }
        return content;
      },
      get serializable() {
        return {
          filename: this.filename,
          content: this.content
        };
      }
    };
    return FileSpec;
  })();
  
  /**
   * A helper for loading missing data in object graphs. It traverses the graph
   * depth first and queues up any objects that have missing data. Once it has
   * has traversed as many objects that are available it attempts to bundle the
   * missing data requests and then resume from the nodes that weren't ready.
   *
   * NOTE: It provides protection from circular references by keeping track of
   * of loaded references. However, you must be careful not to load any graphs
   * that have references to the catalog or other pages since that will cause the
   * entire PDF document object graph to be traversed.
   */
  var ObjectLoader = (function() {
    function mayHaveChildren(value) {
      return isRef(value) || isDict(value) || isArray(value) || isStream(value);
    }
  
    function addChildren(node, nodesToVisit) {
      var value;
      if (isDict(node) || isStream(node)) {
        var map;
        if (isDict(node)) {
          map = node.map;
        } else {
          map = node.dict.map;
        }
        for (var key in map) {
          value = map[key];
          if (mayHaveChildren(value)) {
            nodesToVisit.push(value);
          }
        }
      } else if (isArray(node)) {
        for (var i = 0, ii = node.length; i < ii; i++) {
          value = node[i];
          if (mayHaveChildren(value)) {
            nodesToVisit.push(value);
          }
        }
      }
    }
  
    function ObjectLoader(obj, keys, xref) {
      this.obj = obj;
      this.keys = keys;
      this.xref = xref;
      this.refSet = null;
      this.capability = null;
    }
  
    ObjectLoader.prototype = {
      load: function ObjectLoader_load() {
        var keys = this.keys;
        this.capability = createPromiseCapability();
        // Don't walk the graph if all the data is already loaded.
        if (!(this.xref.stream instanceof ChunkedStream) ||
            this.xref.stream.getMissingChunks().length === 0) {
          this.capability.resolve();
          return this.capability.promise;
        }
  
        this.refSet = new RefSet();
        // Setup the initial nodes to visit.
        var nodesToVisit = [];
        for (var i = 0; i < keys.length; i++) {
          nodesToVisit.push(this.obj[keys[i]]);
        }
  
        this._walk(nodesToVisit);
        return this.capability.promise;
      },
  
      _walk: function ObjectLoader_walk(nodesToVisit) {
        var nodesToRevisit = [];
        var pendingRequests = [];
        // DFS walk of the object graph.
        while (nodesToVisit.length) {
          var currentNode = nodesToVisit.pop();
  
          // Only references or chunked streams can cause missing data exceptions.
          if (isRef(currentNode)) {
            // Skip nodes that have already been visited.
            if (this.refSet.has(currentNode)) {
              continue;
            }
            try {
              var ref = currentNode;
              this.refSet.put(ref);
              currentNode = this.xref.fetch(currentNode);
            } catch (e) {
              if (!(e instanceof MissingDataException)) {
                throw e;
              }
              nodesToRevisit.push(currentNode);
              pendingRequests.push({ begin: e.begin, end: e.end });
            }
          }
          if (currentNode && currentNode.getBaseStreams) {
            var baseStreams = currentNode.getBaseStreams();
            var foundMissingData = false;
            for (var i = 0; i < baseStreams.length; i++) {
              var stream = baseStreams[i];
              if (stream.getMissingChunks && stream.getMissingChunks().length) {
                foundMissingData = true;
                pendingRequests.push({
                  begin: stream.start,
                  end: stream.end
                });
              }
            }
            if (foundMissingData) {
              nodesToRevisit.push(currentNode);
            }
          }
  
          addChildren(currentNode, nodesToVisit);
        }
  
        if (pendingRequests.length) {
          this.xref.stream.manager.requestRanges(pendingRequests).then(
              function pendingRequestCallback() {
            nodesToVisit = nodesToRevisit;
            for (var i = 0; i < nodesToRevisit.length; i++) {
              var node = nodesToRevisit[i];
              // Remove any reference nodes from the currrent refset so they
              // aren't skipped when we revist them.
              if (isRef(node)) {
                this.refSet.remove(node);
              }
            }
            this._walk(nodesToVisit);
          }.bind(this), this.capability.reject);
          return;
        }
        // Everything is loaded.
        this.refSet = null;
        this.capability.resolve();
      }
    };
  
    return ObjectLoader;
  })();
  
  exports.Catalog = Catalog;
  exports.ObjectLoader = ObjectLoader;
  exports.XRef = XRef;
  }));
  