pdfjs.parser.js

        var output = new Uint8Array(outputLength);
        for (i = 0, j = 0, ii = result.length; i < ii; ++i, j += 16) {
          output.set(result[i], j);
        }
        return output;
      }
    };

    return AES256Cipher;
  })();

  var PDF17 = (function PDF17Closure() {
    function compareByteArrays(array1, array2) {
      if (array1.length !== array2.length) {
        return false;
      }
      for (var i = 0; i < array1.length; i++) {
        if (array1[i] !== array2[i]) {
          return false;
        }
      }
      return true;
    }

    function PDF17() {}

    PDF17.prototype = {
      checkOwnerPassword: function PDF17_checkOwnerPassword(
        password,
        ownerValidationSalt,
        userBytes,
        ownerPassword
      ) {
        var hashData = new Uint8Array(password.length + 56);
        hashData.set(password, 0);
        hashData.set(ownerValidationSalt, password.length);
        hashData.set(userBytes, password.length + ownerValidationSalt.length);
        var result = calculateSHA256(hashData, 0, hashData.length);
        return compareByteArrays(result, ownerPassword);
      },
      checkUserPassword: function PDF17_checkUserPassword(
        password,
        userValidationSalt,
        userPassword
      ) {
        var hashData = new Uint8Array(password.length + 8);
        hashData.set(password, 0);
        hashData.set(userValidationSalt, password.length);
        var result = calculateSHA256(hashData, 0, hashData.length);
        return compareByteArrays(result, userPassword);
      },
      getOwnerKey: function PDF17_getOwnerKey(
        password,
        ownerKeySalt,
        userBytes,
        ownerEncryption
      ) {
        var hashData = new Uint8Array(password.length + 56);
        hashData.set(password, 0);
        hashData.set(ownerKeySalt, password.length);
        hashData.set(userBytes, password.length + ownerKeySalt.length);
        var key = calculateSHA256(hashData, 0, hashData.length);
        var cipher = new AES256Cipher(key);
        return cipher.decryptBlock(ownerEncryption, false, new Uint8Array(16));
      },
      getUserKey: function PDF17_getUserKey(
        password,
        userKeySalt,
        userEncryption
      ) {
        var hashData = new Uint8Array(password.length + 8);
        hashData.set(password, 0);
        hashData.set(userKeySalt, password.length);
        //key is the decryption key for the UE string
        var key = calculateSHA256(hashData, 0, hashData.length);
        var cipher = new AES256Cipher(key);
        return cipher.decryptBlock(userEncryption, false, new Uint8Array(16));
      }
    };
    return PDF17;
  })();

  var PDF20 = (function PDF20Closure() {
    function concatArrays(array1, array2) {
      var t = new Uint8Array(array1.length + array2.length);
      t.set(array1, 0);
      t.set(array2, array1.length);
      return t;
    }

    function calculatePDF20Hash(password, input, userBytes) {
      //This refers to Algorithm 2.B as defined in ISO 32000-2
      var k = calculateSHA256(input, 0, input.length).subarray(0, 32);
      var e = [0];
      var i = 0;
      while (i < 64 || e[e.length - 1] > i - 32) {
        var arrayLength = password.length + k.length + userBytes.length;

        var k1 = new Uint8Array(arrayLength * 64);
        var array = concatArrays(password, k);
        array = concatArrays(array, userBytes);
        for (var j = 0, pos = 0; j < 64; j++, pos += arrayLength) {
          k1.set(array, pos);
        }
        //AES128 CBC NO PADDING with
        //first 16 bytes of k as the key and the second 16 as the iv.
        var cipher = new AES128Cipher(k.subarray(0, 16));
        e = cipher.encrypt(k1, k.subarray(16, 32));
        //Now we have to take the first 16 bytes of an unsigned
        //big endian integer... and compute the remainder
        //modulo 3.... That is a fairly large number and
        //JavaScript isn't going to handle that well...
        //So we're using a trick that allows us to perform
        //modulo math byte by byte
        var remainder = 0;
        for (var z = 0; z < 16; z++) {
          remainder *= 256 % 3;
          remainder %= 3;
          remainder += (e[z] >>> 0) % 3;
          remainder %= 3;
        }
        if (remainder === 0) {
          k = calculateSHA256(e, 0, e.length);
        } else if (remainder === 1) {
          k = calculateSHA384(e, 0, e.length);
        } else if (remainder === 2) {
          k = calculateSHA512(e, 0, e.length);
        }
        i++;
      }
      return k.subarray(0, 32);
    }

    function PDF20() {}

    function compareByteArrays(array1, array2) {
      if (array1.length !== array2.length) {
        return false;
      }
      for (var i = 0; i < array1.length; i++) {
        if (array1[i] !== array2[i]) {
          return false;
        }
      }
      return true;
    }

    PDF20.prototype = {
      hash: function PDF20_hash(password, concatBytes, userBytes) {
        return calculatePDF20Hash(password, concatBytes, userBytes);
      },
      checkOwnerPassword: function PDF20_checkOwnerPassword(
        password,
        ownerValidationSalt,
        userBytes,
        ownerPassword
      ) {
        var hashData = new Uint8Array(password.length + 56);
        hashData.set(password, 0);
        hashData.set(ownerValidationSalt, password.length);
        hashData.set(userBytes, password.length + ownerValidationSalt.length);
        var result = calculatePDF20Hash(password, hashData, userBytes);
        return compareByteArrays(result, ownerPassword);
      },
      checkUserPassword: function PDF20_checkUserPassword(
        password,
        userValidationSalt,
        userPassword
      ) {
        var hashData = new Uint8Array(password.length + 8);
        hashData.set(password, 0);
        hashData.set(userValidationSalt, password.length);
        var result = calculatePDF20Hash(password, hashData, []);
        return compareByteArrays(result, userPassword);
      },
      getOwnerKey: function PDF20_getOwnerKey(
        password,
        ownerKeySalt,
        userBytes,
        ownerEncryption
      ) {
        var hashData = new Uint8Array(password.length + 56);
        hashData.set(password, 0);
        hashData.set(ownerKeySalt, password.length);
        hashData.set(userBytes, password.length + ownerKeySalt.length);
        var key = calculatePDF20Hash(password, hashData, userBytes);
        var cipher = new AES256Cipher(key);
        return cipher.decryptBlock(ownerEncryption, false, new Uint8Array(16));
      },
      getUserKey: function PDF20_getUserKey(
        password,
        userKeySalt,
        userEncryption
      ) {
        var hashData = new Uint8Array(password.length + 8);
        hashData.set(password, 0);
        hashData.set(userKeySalt, password.length);
        //key is the decryption key for the UE string
        var key = calculatePDF20Hash(password, hashData, []);
        var cipher = new AES256Cipher(key);
        return cipher.decryptBlock(userEncryption, false, new Uint8Array(16));
      }
    };
    return PDF20;
  })();

  var CipherTransform = (function CipherTransformClosure() {
    function CipherTransform(stringCipherConstructor, streamCipherConstructor) {
      this.stringCipherConstructor = stringCipherConstructor;
      this.streamCipherConstructor = streamCipherConstructor;
    }

    CipherTransform.prototype = {
      createStream: function CipherTransform_createStream(stream, length) {
        var cipher = new this.streamCipherConstructor();
        return new DecryptStream(
          stream,
          length,
          function cipherTransformDecryptStream(data, finalize) {
            return cipher.decryptBlock(data, finalize);
          }
        );
      },
      decryptString: function CipherTransform_decryptString(s) {
        var cipher = new this.stringCipherConstructor();
        var data = stringToBytes(s);
        data = cipher.decryptBlock(data, true);
        return bytesToString(data);
      }
    };
    return CipherTransform;
  })();

  var CipherTransformFactory = (function CipherTransformFactoryClosure() {
    var defaultPasswordBytes = new Uint8Array([
      0x28,
      0xbf,
      0x4e,
      0x5e,
      0x4e,
      0x75,
      0x8a,
      0x41,
      0x64,
      0x00,
      0x4e,
      0x56,
      0xff,
      0xfa,
      0x01,
      0x08,
      0x2e,
      0x2e,
      0x00,
      0xb6,
      0xd0,
      0x68,
      0x3e,
      0x80,
      0x2f,
      0x0c,
      0xa9,
      0xfe,
      0x64,
      0x53,
      0x69,
      0x7a
    ]);

    function createEncryptionKey20(
      revision,
      password,
      ownerPassword,
      ownerValidationSalt,
      ownerKeySalt,
      uBytes,
      userPassword,
      userValidationSalt,
      userKeySalt,
      ownerEncryption,
      userEncryption,
      perms
    ) {
      if (password) {
        var passwordLength = Math.min(127, password.length);
        password = password.subarray(0, passwordLength);
      } else {
        password = [];
      }
      var pdfAlgorithm;
      if (revision === 6) {
        pdfAlgorithm = new PDF20();
      } else {
        pdfAlgorithm = new PDF17();
      }

      if (pdfAlgorithm) {
        if (
          pdfAlgorithm.checkUserPassword(
            password,
            userValidationSalt,
            userPassword
          )
        ) {
          return pdfAlgorithm.getUserKey(password, userKeySalt, userEncryption);
        } else if (
          password.length &&
          pdfAlgorithm.checkOwnerPassword(
            password,
            ownerValidationSalt,
            uBytes,
            ownerPassword
          )
        ) {
          return pdfAlgorithm.getOwnerKey(
            password,
            ownerKeySalt,
            uBytes,
            ownerEncryption
          );
        }
      }

      return null;
    }

    function prepareKeyData(
      fileId,
      password,
      ownerPassword,
      userPassword,
      flags,
      revision,
      keyLength,
      encryptMetadata
    ) {
      var hashDataSize = 40 + ownerPassword.length + fileId.length;
      var hashData = new Uint8Array(hashDataSize),
        i = 0,
        j,
        n;
      if (password) {
        n = Math.min(32, password.length);
        for (; i < n; ++i) {
          hashData[i] = password[i];
        }
      }
      j = 0;
      while (i < 32) {
        hashData[i++] = defaultPasswordBytes[j++];
      }
      // as now the padded password in the hashData[0..i]
      for (j = 0, n = ownerPassword.length; j < n; ++j) {
        hashData[i++] = ownerPassword[j];
      }
      hashData[i++] = flags & 0xff;
      hashData[i++] = (flags >> 8) & 0xff;
      hashData[i++] = (flags >> 16) & 0xff;
      hashData[i++] = (flags >>> 24) & 0xff;
      for (j = 0, n = fileId.length; j < n; ++j) {
        hashData[i++] = fileId[j];
      }
      if (revision >= 4 && !encryptMetadata) {
        hashData[i++] = 0xff;
        hashData[i++] = 0xff;
        hashData[i++] = 0xff;
        hashData[i++] = 0xff;
      }
      var hash = calculateMD5(hashData, 0, i);
      var keyLengthInBytes = keyLength >> 3;
      if (revision >= 3) {
        for (j = 0; j < 50; ++j) {
          hash = calculateMD5(hash, 0, keyLengthInBytes);
        }
      }
      var encryptionKey = hash.subarray(0, keyLengthInBytes);
      var cipher, checkData;

      if (revision >= 3) {
        for (i = 0; i < 32; ++i) {
          hashData[i] = defaultPasswordBytes[i];
        }
        for (j = 0, n = fileId.length; j < n; ++j) {
          hashData[i++] = fileId[j];
        }
        cipher = new ARCFourCipher(encryptionKey);
        checkData = cipher.encryptBlock(calculateMD5(hashData, 0, i));
        n = encryptionKey.length;
        var derivedKey = new Uint8Array(n),
          k;
        for (j = 1; j <= 19; ++j) {
          for (k = 0; k < n; ++k) {
            derivedKey[k] = encryptionKey[k] ^ j;
          }
          cipher = new ARCFourCipher(derivedKey);
          checkData = cipher.encryptBlock(checkData);
        }
        for (j = 0, n = checkData.length; j < n; ++j) {
          if (userPassword[j] !== checkData[j]) {
            return null;
          }
        }
      } else {
        cipher = new ARCFourCipher(encryptionKey);
        checkData = cipher.encryptBlock(defaultPasswordBytes);
        for (j = 0, n = checkData.length; j < n; ++j) {
          if (userPassword[j] !== checkData[j]) {
            return null;
          }
        }
      }
      return encryptionKey;
    }

    function decodeUserPassword(password, ownerPassword, revision, keyLength) {
      var hashData = new Uint8Array(32),
        i = 0,
        j,
        n;
      n = Math.min(32, password.length);
      for (; i < n; ++i) {
        hashData[i] = password[i];
      }
      j = 0;
      while (i < 32) {
        hashData[i++] = defaultPasswordBytes[j++];
      }
      var hash = calculateMD5(hashData, 0, i);
      var keyLengthInBytes = keyLength >> 3;
      if (revision >= 3) {
        for (j = 0; j < 50; ++j) {
          hash = calculateMD5(hash, 0, hash.length);
        }
      }

      var cipher, userPassword;
      if (revision >= 3) {
        userPassword = ownerPassword;
        var derivedKey = new Uint8Array(keyLengthInBytes),
          k;
        for (j = 19; j >= 0; j--) {
          for (k = 0; k < keyLengthInBytes; ++k) {
            derivedKey[k] = hash[k] ^ j;
          }
          cipher = new ARCFourCipher(derivedKey);
          userPassword = cipher.encryptBlock(userPassword);
        }
      } else {
        cipher = new ARCFourCipher(hash.subarray(0, keyLengthInBytes));
        userPassword = cipher.encryptBlock(ownerPassword);
      }
      return userPassword;
    }

    var identityName = Name.get("Identity");

    function CipherTransformFactory(dict, fileId, password) {
      var filter = dict.get("Filter");
      if (!isName(filter) || filter.name !== "Standard") {
        error("unknown encryption method");
      }
      this.dict = dict;
      var algorithm = dict.get("V");
      if (
        !isInt(algorithm) ||
        (algorithm !== 1 &&
          algorithm !== 2 &&
          algorithm !== 4 &&
          algorithm !== 5)
      ) {
        error("unsupported encryption algorithm");
      }
      this.algorithm = algorithm;
      var keyLength = dict.get("Length") || 40;
      if (!isInt(keyLength) || keyLength < 40 || keyLength % 8 !== 0) {
        error("invalid key length");
      }

      // prepare keys
      var ownerPassword = stringToBytes(dict.get("O")).subarray(0, 32);
      var userPassword = stringToBytes(dict.get("U")).subarray(0, 32);
      var flags = dict.get("P");
      var revision = dict.get("R");
      // meaningful when V is 4 or 5
      var encryptMetadata =
        (algorithm === 4 || algorithm === 5) &&
        dict.get("EncryptMetadata") !== false;
      this.encryptMetadata = encryptMetadata;

      var fileIdBytes = stringToBytes(fileId);
      var passwordBytes;
      if (password) {
        if (revision === 6) {
          try {
            password = utf8StringToString(password);
          } catch (ex) {
            warn(
              "CipherTransformFactory: " +
                "Unable to convert UTF8 encoded password."
            );
          }
        }
        passwordBytes = stringToBytes(password);
      }

      var encryptionKey;
      if (algorithm !== 5) {
        encryptionKey = prepareKeyData(
          fileIdBytes,
          passwordBytes,
          ownerPassword,
          userPassword,
          flags,
          revision,
          keyLength,
          encryptMetadata
        );
      } else {
        var ownerValidationSalt = stringToBytes(dict.get("O")).subarray(32, 40);
        var ownerKeySalt = stringToBytes(dict.get("O")).subarray(40, 48);
        var uBytes = stringToBytes(dict.get("U")).subarray(0, 48);
        var userValidationSalt = stringToBytes(dict.get("U")).subarray(32, 40);
        var userKeySalt = stringToBytes(dict.get("U")).subarray(40, 48);
        var ownerEncryption = stringToBytes(dict.get("OE"));
        var userEncryption = stringToBytes(dict.get("UE"));
        var perms = stringToBytes(dict.get("Perms"));
        encryptionKey = createEncryptionKey20(
          revision,
          passwordBytes,
          ownerPassword,
          ownerValidationSalt,
          ownerKeySalt,
          uBytes,
          userPassword,
          userValidationSalt,
          userKeySalt,
          ownerEncryption,
          userEncryption,
          perms
        );
      }
      if (!encryptionKey && !password) {
        throw new PasswordException(
          "No password given",
          PasswordResponses.NEED_PASSWORD
        );
      } else if (!encryptionKey && password) {
        // Attempting use the password as an owner password
        var decodedPassword = decodeUserPassword(
          passwordBytes,
          ownerPassword,
          revision,
          keyLength
        );
        encryptionKey = prepareKeyData(
          fileIdBytes,
          decodedPassword,
          ownerPassword,
          userPassword,
          flags,
          revision,
          keyLength,
          encryptMetadata
        );
      }

      if (!encryptionKey) {
        throw new PasswordException(
          "Incorrect Password",
          PasswordResponses.INCORRECT_PASSWORD
        );
      }

      this.encryptionKey = encryptionKey;

      if (algorithm >= 4) {
        this.cf = dict.get("CF");
        this.stmf = dict.get("StmF") || identityName;
        this.strf = dict.get("StrF") || identityName;
        this.eff = dict.get("EFF") || this.stmf;
      }
    }

    function buildObjectKey(num, gen, encryptionKey, isAes) {
      var key = new Uint8Array(encryptionKey.length + 9),
        i,
        n;
      for (i = 0, n = encryptionKey.length; i < n; ++i) {
        key[i] = encryptionKey[i];
      }
      key[i++] = num & 0xff;
      key[i++] = (num >> 8) & 0xff;
      key[i++] = (num >> 16) & 0xff;
      key[i++] = gen & 0xff;
      key[i++] = (gen >> 8) & 0xff;
      if (isAes) {
        key[i++] = 0x73;
        key[i++] = 0x41;
        key[i++] = 0x6c;
        key[i++] = 0x54;
      }
      var hash = calculateMD5(key, 0, i);
      return hash.subarray(0, Math.min(encryptionKey.length + 5, 16));
    }

    function buildCipherConstructor(cf, name, num, gen, key) {
      var cryptFilter = cf.get(name.name);
      var cfm;
      if (cryptFilter !== null && cryptFilter !== undefined) {
        cfm = cryptFilter.get("CFM");
      }
      if (!cfm || cfm.name === "None") {
        return function cipherTransformFactoryBuildCipherConstructorNone() {
          return new NullCipher();
        };
      }
      if ("V2" === cfm.name) {
        return function cipherTransformFactoryBuildCipherConstructorV2() {
          return new ARCFourCipher(buildObjectKey(num, gen, key, false));
        };
      }
      if ("AESV2" === cfm.name) {
        return function cipherTransformFactoryBuildCipherConstructorAESV2() {
          return new AES128Cipher(buildObjectKey(num, gen, key, true));
        };
      }
      if ("AESV3" === cfm.name) {
        return function cipherTransformFactoryBuildCipherConstructorAESV3() {
          return new AES256Cipher(key);
        };
      }
      error("Unknown crypto method");
    }

    CipherTransformFactory.prototype = {
      createCipherTransform: function CipherTransformFactory_createCipherTransform(
        num,
        gen
      ) {
        if (this.algorithm === 4 || this.algorithm === 5) {
          return new CipherTransform(
            buildCipherConstructor(
              this.cf,
              this.stmf,
              num,
              gen,
              this.encryptionKey
            ),
            buildCipherConstructor(
              this.cf,
              this.strf,
              num,
              gen,
              this.encryptionKey
            )
          );
        }
        // algorithms 1 and 2
        var key = buildObjectKey(num, gen, this.encryptionKey, false);
        var cipherConstructor = function buildCipherCipherConstructor() {
          return new ARCFourCipher(key);
        };
        return new CipherTransform(cipherConstructor, cipherConstructor);
      }
    };

    return CipherTransformFactory;
  })();

  exports.AES128Cipher = AES128Cipher;
  exports.AES256Cipher = AES256Cipher;
  exports.ARCFourCipher = ARCFourCipher;
  exports.CipherTransformFactory = CipherTransformFactory;
  exports.PDF17 = PDF17;
  exports.PDF20 = PDF20;
  exports.calculateMD5 = calculateMD5;
  exports.calculateSHA256 = calculateSHA256;
  exports.calculateSHA384 = calculateSHA384;
  exports.calculateSHA512 = calculateSHA512;
});

/* 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
  );
  //}
})(window, 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();