pdfjs-dist 2.6.347 → 2.7.570

package/lib/test/unit/crypto_spec.js

@@ -29,17 +29,15 @@ var _util = require("../../shared/util.js");
 
 describe("crypto", function () {
   function hex2binary(s) {
-    var digits = "0123456789ABCDEF";
+    const digits = "0123456789ABCDEF";
     s = s.toUpperCase();
-    var n = s.length >> 1,
-        i,
-        j;
-    var result = new Uint8Array(n);
+    const n = s.length >> 1;
+    const result = new Uint8Array(n);
 
-    for (i = 0, j = 0; i < n; ++i) {
-      var d1 = s.charAt(j++);
-      var d2 = s.charAt(j++);
-      var value = digits.indexOf(d1) << 4 | digits.indexOf(d2);
+    for (let i = 0, j = 0; i < n; ++i) {
+      const d1 = s.charAt(j++);
+      const d2 = s.charAt(j++);
+      const value = digits.indexOf(d1) << 4 | digits.indexOf(d2);
       result[i] = value;
     }
 
@@ -48,189 +46,167 @@ describe("crypto", function () {
 
   describe("calculateMD5", function () {
     it("should pass RFC 1321 test #1", function () {
-      var input, result, expected;
-      input = (0, _util.stringToBytes)("");
-      result = (0, _crypto.calculateMD5)(input, 0, input.length);
-      expected = hex2binary("d41d8cd98f00b204e9800998ecf8427e");
+      const input = (0, _util.stringToBytes)("");
+      const result = (0, _crypto.calculateMD5)(input, 0, input.length);
+      const expected = hex2binary("d41d8cd98f00b204e9800998ecf8427e");
       expect(result).toEqual(expected);
     });
     it("should pass RFC 1321 test #2", function () {
-      var input, result, expected;
-      input = (0, _util.stringToBytes)("a");
-      result = (0, _crypto.calculateMD5)(input, 0, input.length);
-      expected = hex2binary("0cc175b9c0f1b6a831c399e269772661");
+      const input = (0, _util.stringToBytes)("a");
+      const result = (0, _crypto.calculateMD5)(input, 0, input.length);
+      const expected = hex2binary("0cc175b9c0f1b6a831c399e269772661");
       expect(result).toEqual(expected);
     });
     it("should pass RFC 1321 test #3", function () {
-      var input, result, expected;
-      input = (0, _util.stringToBytes)("abc");
-      result = (0, _crypto.calculateMD5)(input, 0, input.length);
-      expected = hex2binary("900150983cd24fb0d6963f7d28e17f72");
+      const input = (0, _util.stringToBytes)("abc");
+      const result = (0, _crypto.calculateMD5)(input, 0, input.length);
+      const expected = hex2binary("900150983cd24fb0d6963f7d28e17f72");
       expect(result).toEqual(expected);
     });
     it("should pass RFC 1321 test #4", function () {
-      var input, result, expected;
-      input = (0, _util.stringToBytes)("message digest");
-      result = (0, _crypto.calculateMD5)(input, 0, input.length);
-      expected = hex2binary("f96b697d7cb7938d525a2f31aaf161d0");
+      const input = (0, _util.stringToBytes)("message digest");
+      const result = (0, _crypto.calculateMD5)(input, 0, input.length);
+      const expected = hex2binary("f96b697d7cb7938d525a2f31aaf161d0");
       expect(result).toEqual(expected);
     });
     it("should pass RFC 1321 test #5", function () {
-      var input, result, expected;
-      input = (0, _util.stringToBytes)("abcdefghijklmnopqrstuvwxyz");
-      result = (0, _crypto.calculateMD5)(input, 0, input.length);
-      expected = hex2binary("c3fcd3d76192e4007dfb496cca67e13b");
+      const input = (0, _util.stringToBytes)("abcdefghijklmnopqrstuvwxyz");
+      const result = (0, _crypto.calculateMD5)(input, 0, input.length);
+      const expected = hex2binary("c3fcd3d76192e4007dfb496cca67e13b");
       expect(result).toEqual(expected);
     });
     it("should pass RFC 1321 test #6", function () {
-      var input, result, expected;
-      input = (0, _util.stringToBytes)("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789");
-      result = (0, _crypto.calculateMD5)(input, 0, input.length);
-      expected = hex2binary("d174ab98d277d9f5a5611c2c9f419d9f");
+      const input = (0, _util.stringToBytes)("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789");
+      const result = (0, _crypto.calculateMD5)(input, 0, input.length);
+      const expected = hex2binary("d174ab98d277d9f5a5611c2c9f419d9f");
       expect(result).toEqual(expected);
     });
     it("should pass RFC 1321 test #7", function () {
-      var input, result, expected;
-      input = (0, _util.stringToBytes)("123456789012345678901234567890123456789012345678" + "90123456789012345678901234567890");
-      result = (0, _crypto.calculateMD5)(input, 0, input.length);
-      expected = hex2binary("57edf4a22be3c955ac49da2e2107b67a");
+      const input = (0, _util.stringToBytes)("123456789012345678901234567890123456789012345678" + "90123456789012345678901234567890");
+      const result = (0, _crypto.calculateMD5)(input, 0, input.length);
+      const expected = hex2binary("57edf4a22be3c955ac49da2e2107b67a");
       expect(result).toEqual(expected);
     });
   });
   describe("ARCFourCipher", function () {
     it("should pass test #1", function () {
-      var key, input, result, expected, cipher;
-      key = hex2binary("0123456789abcdef");
-      input = hex2binary("0123456789abcdef");
-      cipher = new _crypto.ARCFourCipher(key);
-      result = cipher.encryptBlock(input);
-      expected = hex2binary("75b7878099e0c596");
+      const key = hex2binary("0123456789abcdef");
+      const input = hex2binary("0123456789abcdef");
+      const cipher = new _crypto.ARCFourCipher(key);
+      const result = cipher.encryptBlock(input);
+      const expected = hex2binary("75b7878099e0c596");
       expect(result).toEqual(expected);
     });
     it("should pass test #2", function () {
-      var key, input, result, expected, cipher;
-      key = hex2binary("0123456789abcdef");
-      input = hex2binary("0000000000000000");
-      cipher = new _crypto.ARCFourCipher(key);
-      result = cipher.encryptBlock(input);
-      expected = hex2binary("7494c2e7104b0879");
+      const key = hex2binary("0123456789abcdef");
+      const input = hex2binary("0000000000000000");
+      const cipher = new _crypto.ARCFourCipher(key);
+      const result = cipher.encryptBlock(input);
+      const expected = hex2binary("7494c2e7104b0879");
       expect(result).toEqual(expected);
     });
     it("should pass test #3", function () {
-      var key, input, result, expected, cipher;
-      key = hex2binary("0000000000000000");
-      input = hex2binary("0000000000000000");
-      cipher = new _crypto.ARCFourCipher(key);
-      result = cipher.encryptBlock(input);
-      expected = hex2binary("de188941a3375d3a");
+      const key = hex2binary("0000000000000000");
+      const input = hex2binary("0000000000000000");
+      const cipher = new _crypto.ARCFourCipher(key);
+      const result = cipher.encryptBlock(input);
+      const expected = hex2binary("de188941a3375d3a");
       expect(result).toEqual(expected);
     });
     it("should pass test #4", function () {
-      var key, input, result, expected, cipher;
-      key = hex2binary("ef012345");
-      input = hex2binary("00000000000000000000");
-      cipher = new _crypto.ARCFourCipher(key);
-      result = cipher.encryptBlock(input);
-      expected = hex2binary("d6a141a7ec3c38dfbd61");
+      const key = hex2binary("ef012345");
+      const input = hex2binary("00000000000000000000");
+      const cipher = new _crypto.ARCFourCipher(key);
+      const result = cipher.encryptBlock(input);
+      const expected = hex2binary("d6a141a7ec3c38dfbd61");
       expect(result).toEqual(expected);
     });
     it("should pass test #5", function () {
-      var key, input, result, expected, cipher;
-      key = hex2binary("0123456789abcdef");
-      input = hex2binary("010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "101010101010101010101");
-      cipher = new _crypto.ARCFourCipher(key);
-      result = cipher.encryptBlock(input);
-      expected = hex2binary("7595c3e6114a09780c4ad452338e1ffd9a1be9498f813d76" + "533449b6778dcad8c78a8d2ba9ac66085d0e53d59c26c2d1c490c1ebbe0ce66d1b6b" + "1b13b6b919b847c25a91447a95e75e4ef16779cde8bf0a95850e32af9689444fd377" + "108f98fdcbd4e726567500990bcc7e0ca3c4aaa304a387d20f3b8fbbcd42a1bd311d" + "7a4303dda5ab078896ae80c18b0af66dff319616eb784e495ad2ce90d7f772a81747" + "b65f62093b1e0db9e5ba532fafec47508323e671327df9444432cb7367cec82f5d44" + "c0d00b67d650a075cd4b70dedd77eb9b10231b6b5b741347396d62897421d43df9b4" + "2e446e358e9c11a9b2184ecbef0cd8e7a877ef968f1390ec9b3d35a5585cb009290e" + "2fcde7b5ec66d9084be44055a619d9dd7fc3166f9487f7cb272912426445998514c1" + "5d53a18c864ce3a2b7555793988126520eacf2e3066e230c91bee4dd5304f5fd0405" + "b35bd99c73135d3d9bc335ee049ef69b3867bf2d7bd1eaa595d8bfc0066ff8d31509" + "eb0c6caa006c807a623ef84c3d33c195d23ee320c40de0558157c822d4b8c569d849" + "aed59d4e0fd7f379586b4b7ff684ed6a189f7486d49b9c4bad9ba24b96abf924372c" + "8a8fffb10d55354900a77a3db5f205e1b99fcd8660863a159ad4abe40fa48934163d" + "dde542a6585540fd683cbfd8c00f12129a284deacc4cdefe58be7137541c047126c8" + "d49e2755ab181ab7e940b0c0");
+      const key = hex2binary("0123456789abcdef");
+      const input = hex2binary("010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "10101010101010101010101010101010101010101010101010101010101010101010" + "101010101010101010101");
+      const cipher = new _crypto.ARCFourCipher(key);
+      const result = cipher.encryptBlock(input);
+      const expected = hex2binary("7595c3e6114a09780c4ad452338e1ffd9a1be9498f813d76" + "533449b6778dcad8c78a8d2ba9ac66085d0e53d59c26c2d1c490c1ebbe0ce66d1b6b" + "1b13b6b919b847c25a91447a95e75e4ef16779cde8bf0a95850e32af9689444fd377" + "108f98fdcbd4e726567500990bcc7e0ca3c4aaa304a387d20f3b8fbbcd42a1bd311d" + "7a4303dda5ab078896ae80c18b0af66dff319616eb784e495ad2ce90d7f772a81747" + "b65f62093b1e0db9e5ba532fafec47508323e671327df9444432cb7367cec82f5d44" + "c0d00b67d650a075cd4b70dedd77eb9b10231b6b5b741347396d62897421d43df9b4" + "2e446e358e9c11a9b2184ecbef0cd8e7a877ef968f1390ec9b3d35a5585cb009290e" + "2fcde7b5ec66d9084be44055a619d9dd7fc3166f9487f7cb272912426445998514c1" + "5d53a18c864ce3a2b7555793988126520eacf2e3066e230c91bee4dd5304f5fd0405" + "b35bd99c73135d3d9bc335ee049ef69b3867bf2d7bd1eaa595d8bfc0066ff8d31509" + "eb0c6caa006c807a623ef84c3d33c195d23ee320c40de0558157c822d4b8c569d849" + "aed59d4e0fd7f379586b4b7ff684ed6a189f7486d49b9c4bad9ba24b96abf924372c" + "8a8fffb10d55354900a77a3db5f205e1b99fcd8660863a159ad4abe40fa48934163d" + "dde542a6585540fd683cbfd8c00f12129a284deacc4cdefe58be7137541c047126c8" + "d49e2755ab181ab7e940b0c0");
       expect(result).toEqual(expected);
     });
     it("should pass test #6", function () {
-      var key, input, result, expected, cipher;
-      key = hex2binary("fb029e3031323334");
-      input = hex2binary("aaaa0300000008004500004e661a00008011be640a0001220af" + "fffff00890089003a000080a601100001000000000000204543454a4548454346434" + "550464545494546464343414341434143414341414100002000011bd0b604");
-      cipher = new _crypto.ARCFourCipher(key);
-      result = cipher.encryptBlock(input);
-      expected = hex2binary("f69c5806bd6ce84626bcbefb9474650aad1f7909b0f64d5f" + "58a503a258b7ed22eb0ea64930d3a056a55742fcce141d485f8aa836dea18df42c53" + "80805ad0c61a5d6f58f41040b24b7d1a693856ed0d4398e7aee3bf0e2a2ca8f7");
+      const key = hex2binary("fb029e3031323334");
+      const input = hex2binary("aaaa0300000008004500004e661a00008011be640a0001220af" + "fffff00890089003a000080a601100001000000000000204543454a4548454346434" + "550464545494546464343414341434143414341414100002000011bd0b604");
+      const cipher = new _crypto.ARCFourCipher(key);
+      const result = cipher.encryptBlock(input);
+      const expected = hex2binary("f69c5806bd6ce84626bcbefb9474650aad1f7909b0f64d5f" + "58a503a258b7ed22eb0ea64930d3a056a55742fcce141d485f8aa836dea18df42c53" + "80805ad0c61a5d6f58f41040b24b7d1a693856ed0d4398e7aee3bf0e2a2ca8f7");
       expect(result).toEqual(expected);
     });
     it("should pass test #7", function () {
-      var key, input, result, expected, cipher;
-      key = hex2binary("0123456789abcdef");
-      input = hex2binary("123456789abcdef0123456789abcdef0123456789abcdef012345678");
-      cipher = new _crypto.ARCFourCipher(key);
-      result = cipher.encryptBlock(input);
-      expected = hex2binary("66a0949f8af7d6891f7f832ba833c00c892ebe30143ce28740011ecf");
+      const key = hex2binary("0123456789abcdef");
+      const input = hex2binary("123456789abcdef0123456789abcdef0123456789abcdef012345678");
+      const cipher = new _crypto.ARCFourCipher(key);
+      const result = cipher.encryptBlock(input);
+      const expected = hex2binary("66a0949f8af7d6891f7f832ba833c00c892ebe30143ce28740011ecf");
       expect(result).toEqual(expected);
     });
   });
   describe("calculateSHA256", function () {
     it("should properly hash abc", function () {
-      var input, result, expected;
-      input = (0, _util.stringToBytes)("abc");
-      result = (0, _crypto.calculateSHA256)(input, 0, input.length);
-      expected = hex2binary("BA7816BF8F01CFEA414140DE5DAE2223B00361A396177A9CB410FF61F20015AD");
+      const input = (0, _util.stringToBytes)("abc");
+      const result = (0, _crypto.calculateSHA256)(input, 0, input.length);
+      const expected = hex2binary("BA7816BF8F01CFEA414140DE5DAE2223B00361A396177A9CB410FF61F20015AD");
       expect(result).toEqual(expected);
     });
     it("should properly hash a multiblock input", function () {
-      var input, result, expected;
-      input = (0, _util.stringToBytes)("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq");
-      result = (0, _crypto.calculateSHA256)(input, 0, input.length);
-      expected = hex2binary("248D6A61D20638B8E5C026930C3E6039A33CE45964FF2167F6ECEDD419DB06C1");
+      const input = (0, _util.stringToBytes)("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq");
+      const result = (0, _crypto.calculateSHA256)(input, 0, input.length);
+      const expected = hex2binary("248D6A61D20638B8E5C026930C3E6039A33CE45964FF2167F6ECEDD419DB06C1");
       expect(result).toEqual(expected);
     });
   });
   describe("calculateSHA384", function () {
     it("should properly hash abc", function () {
-      var input, result, expected;
-      input = (0, _util.stringToBytes)("abc");
-      result = (0, _crypto.calculateSHA384)(input, 0, input.length);
-      expected = hex2binary("CB00753F45A35E8BB5A03D699AC65007272C32AB0EDED163" + "1A8B605A43FF5BED8086072BA1E7CC2358BAECA134C825A7");
+      const input = (0, _util.stringToBytes)("abc");
+      const result = (0, _crypto.calculateSHA384)(input, 0, input.length);
+      const expected = hex2binary("CB00753F45A35E8BB5A03D699AC65007272C32AB0EDED163" + "1A8B605A43FF5BED8086072BA1E7CC2358BAECA134C825A7");
       expect(result).toEqual(expected);
     });
     it("should properly hash a multiblock input", function () {
-      var input, result, expected;
-      input = (0, _util.stringToBytes)("abcdefghbcdefghicdefghijdefghijkefghijklfghijklm" + "ghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrs" + "mnopqrstnopqrstu");
-      result = (0, _crypto.calculateSHA384)(input, 0, input.length);
-      expected = hex2binary("09330C33F71147E83D192FC782CD1B4753111B173B3B05D2" + "2FA08086E3B0F712FCC7C71A557E2DB966C3E9FA91746039");
+      const input = (0, _util.stringToBytes)("abcdefghbcdefghicdefghijdefghijkefghijklfghijklm" + "ghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrs" + "mnopqrstnopqrstu");
+      const result = (0, _crypto.calculateSHA384)(input, 0, input.length);
+      const expected = hex2binary("09330C33F71147E83D192FC782CD1B4753111B173B3B05D2" + "2FA08086E3B0F712FCC7C71A557E2DB966C3E9FA91746039");
       expect(result).toEqual(expected);
     });
   });
   describe("calculateSHA512", function () {
     it("should properly hash abc", function () {
-      var input, result, expected;
-      input = (0, _util.stringToBytes)("abc");
-      result = (0, _crypto.calculateSHA512)(input, 0, input.length);
-      expected = hex2binary("DDAF35A193617ABACC417349AE20413112E6FA4E89A97EA2" + "0A9EEEE64B55D39A2192992A274FC1A836BA3C23A3FEEBBD" + "454D4423643CE80E2A9AC94FA54CA49F");
+      const input = (0, _util.stringToBytes)("abc");
+      const result = (0, _crypto.calculateSHA512)(input, 0, input.length);
+      const expected = hex2binary("DDAF35A193617ABACC417349AE20413112E6FA4E89A97EA2" + "0A9EEEE64B55D39A2192992A274FC1A836BA3C23A3FEEBBD" + "454D4423643CE80E2A9AC94FA54CA49F");
       expect(result).toEqual(expected);
     });
     it("should properly hash a multiblock input", function () {
-      var input, result, expected;
-      input = (0, _util.stringToBytes)("abcdefghbcdefghicdefghijdefghijkefghijklfghijklm" + "ghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrs" + "mnopqrstnopqrstu");
-      result = (0, _crypto.calculateSHA512)(input, 0, input.length);
-      expected = hex2binary("8E959B75DAE313DA8CF4F72814FC143F8F7779C6EB9F7FA1" + "7299AEADB6889018501D289E4900F7E4331B99DEC4B5433A" + "C7D329EEB6DD26545E96E55B874BE909");
+      const input = (0, _util.stringToBytes)("abcdefghbcdefghicdefghijdefghijkefghijklfghijklm" + "ghijklmnhijklmnoijklmnopjklmnopqklmnopqrlmnopqrs" + "mnopqrstnopqrstu");
+      const result = (0, _crypto.calculateSHA512)(input, 0, input.length);
+      const expected = hex2binary("8E959B75DAE313DA8CF4F72814FC143F8F7779C6EB9F7FA1" + "7299AEADB6889018501D289E4900F7E4331B99DEC4B5433A" + "C7D329EEB6DD26545E96E55B874BE909");
       expect(result).toEqual(expected);
     });
   });
   describe("AES128", function () {
     describe("Encryption", function () {
       it("should be able to encrypt a block", function () {
-        var input, key, result, expected, iv, cipher;
-        input = hex2binary("00112233445566778899aabbccddeeff");
-        key = hex2binary("000102030405060708090a0b0c0d0e0f");
-        iv = hex2binary("00000000000000000000000000000000");
-        cipher = new _crypto.AES128Cipher(key);
-        result = cipher.encrypt(input, iv);
-        expected = hex2binary("69c4e0d86a7b0430d8cdb78070b4c55a");
+        const input = hex2binary("00112233445566778899aabbccddeeff");
+        const key = hex2binary("000102030405060708090a0b0c0d0e0f");
+        const iv = hex2binary("00000000000000000000000000000000");
+        const cipher = new _crypto.AES128Cipher(key);
+        const result = cipher.encrypt(input, iv);
+        const expected = hex2binary("69c4e0d86a7b0430d8cdb78070b4c55a");
         expect(result).toEqual(expected);
       });
     });
     describe("Decryption", function () {
       it("should be able to decrypt a block with IV in stream", function () {
-        var input, key, result, expected, cipher;
-        input = hex2binary("0000000000000000000000000000000069c4e0d86a7b0430d" + "8cdb78070b4c55a");
-        key = hex2binary("000102030405060708090a0b0c0d0e0f");
-        cipher = new _crypto.AES128Cipher(key);
-        result = cipher.decryptBlock(input);
-        expected = hex2binary("00112233445566778899aabbccddeeff");
+        const input = hex2binary("0000000000000000000000000000000069c4e0d86a7b0430d" + "8cdb78070b4c55a");
+        const key = hex2binary("000102030405060708090a0b0c0d0e0f");
+        const cipher = new _crypto.AES128Cipher(key);
+        const result = cipher.decryptBlock(input);
+        const expected = hex2binary("00112233445566778899aabbccddeeff");
         expect(result).toEqual(expected);
       });
     });
@@ -238,130 +214,117 @@ describe("crypto", function () {
   describe("AES256", function () {
     describe("Encryption", function () {
       it("should be able to encrypt a block", function () {
-        var input, key, result, expected, iv, cipher;
-        input = hex2binary("00112233445566778899aabbccddeeff");
-        key = hex2binary("000102030405060708090a0b0c0d0e0f101112131415161718" + "191a1b1c1d1e1f");
-        iv = hex2binary("00000000000000000000000000000000");
-        cipher = new _crypto.AES256Cipher(key);
-        result = cipher.encrypt(input, iv);
-        expected = hex2binary("8ea2b7ca516745bfeafc49904b496089");
+        const input = hex2binary("00112233445566778899aabbccddeeff");
+        const key = hex2binary("000102030405060708090a0b0c0d0e0f101112131415161718" + "191a1b1c1d1e1f");
+        const iv = hex2binary("00000000000000000000000000000000");
+        const cipher = new _crypto.AES256Cipher(key);
+        const result = cipher.encrypt(input, iv);
+        const expected = hex2binary("8ea2b7ca516745bfeafc49904b496089");
         expect(result).toEqual(expected);
       });
     });
     describe("Decryption", function () {
       it("should be able to decrypt a block with specified iv", function () {
-        var input, key, result, expected, cipher, iv;
-        input = hex2binary("8ea2b7ca516745bfeafc49904b496089");
-        key = hex2binary("000102030405060708090a0b0c0d0e0f101112131415161718" + "191a1b1c1d1e1f");
-        iv = hex2binary("00000000000000000000000000000000");
-        cipher = new _crypto.AES256Cipher(key);
-        result = cipher.decryptBlock(input, false, iv);
-        expected = hex2binary("00112233445566778899aabbccddeeff");
+        const input = hex2binary("8ea2b7ca516745bfeafc49904b496089");
+        const key = hex2binary("000102030405060708090a0b0c0d0e0f101112131415161718" + "191a1b1c1d1e1f");
+        const iv = hex2binary("00000000000000000000000000000000");
+        const cipher = new _crypto.AES256Cipher(key);
+        const result = cipher.decryptBlock(input, false, iv);
+        const expected = hex2binary("00112233445566778899aabbccddeeff");
         expect(result).toEqual(expected);
       });
       it("should be able to decrypt a block with IV in stream", function () {
-        var input, key, result, expected, cipher;
-        input = hex2binary("000000000000000000000000000000008ea2b7ca516745bf" + "eafc49904b496089");
-        key = hex2binary("000102030405060708090a0b0c0d0e0f101112131415161718" + "191a1b1c1d1e1f");
-        cipher = new _crypto.AES256Cipher(key);
-        result = cipher.decryptBlock(input, false);
-        expected = hex2binary("00112233445566778899aabbccddeeff");
+        const input = hex2binary("000000000000000000000000000000008ea2b7ca516745bf" + "eafc49904b496089");
+        const key = hex2binary("000102030405060708090a0b0c0d0e0f101112131415161718" + "191a1b1c1d1e1f");
+        const cipher = new _crypto.AES256Cipher(key);
+        const result = cipher.decryptBlock(input, false);
+        const expected = hex2binary("00112233445566778899aabbccddeeff");
         expect(result).toEqual(expected);
       });
     });
   });
   describe("PDF17Algorithm", function () {
     it("should correctly check a user key", function () {
-      var password, userValidation, userPassword, alg, result;
-      alg = new _crypto.PDF17();
-      password = new Uint8Array([117, 115, 101, 114]);
-      userValidation = new Uint8Array([117, 169, 4, 32, 159, 101, 22, 220]);
-      userPassword = new Uint8Array([131, 242, 143, 160, 87, 2, 138, 134, 79, 253, 189, 173, 224, 73, 144, 241, 190, 81, 197, 15, 249, 105, 145, 151, 15, 194, 65, 3, 1, 126, 187, 221]);
-      result = alg.checkUserPassword(password, userValidation, userPassword);
+      const alg = new _crypto.PDF17();
+      const password = new Uint8Array([117, 115, 101, 114]);
+      const userValidation = new Uint8Array([117, 169, 4, 32, 159, 101, 22, 220]);
+      const userPassword = new Uint8Array([131, 242, 143, 160, 87, 2, 138, 134, 79, 253, 189, 173, 224, 73, 144, 241, 190, 81, 197, 15, 249, 105, 145, 151, 15, 194, 65, 3, 1, 126, 187, 221]);
+      const result = alg.checkUserPassword(password, userValidation, userPassword);
       expect(result).toEqual(true);
     });
     it("should correctly check an owner key", function () {
-      var password, ownerValidation, ownerPassword, alg, result, uBytes;
-      alg = new _crypto.PDF17();
-      password = new Uint8Array([111, 119, 110, 101, 114]);
-      ownerValidation = new Uint8Array([243, 118, 71, 153, 128, 17, 101, 62]);
-      ownerPassword = new Uint8Array([60, 98, 137, 35, 51, 101, 200, 152, 210, 178, 226, 228, 134, 205, 163, 24, 204, 126, 177, 36, 106, 50, 36, 125, 210, 172, 171, 120, 222, 108, 139, 115]);
-      uBytes = new Uint8Array([131, 242, 143, 160, 87, 2, 138, 134, 79, 253, 189, 173, 224, 73, 144, 241, 190, 81, 197, 15, 249, 105, 145, 151, 15, 194, 65, 3, 1, 126, 187, 221, 117, 169, 4, 32, 159, 101, 22, 220, 168, 94, 215, 192, 100, 38, 188, 40]);
-      result = alg.checkOwnerPassword(password, ownerValidation, uBytes, ownerPassword);
+      const alg = new _crypto.PDF17();
+      const password = new Uint8Array([111, 119, 110, 101, 114]);
+      const ownerValidation = new Uint8Array([243, 118, 71, 153, 128, 17, 101, 62]);
+      const ownerPassword = new Uint8Array([60, 98, 137, 35, 51, 101, 200, 152, 210, 178, 226, 228, 134, 205, 163, 24, 204, 126, 177, 36, 106, 50, 36, 125, 210, 172, 171, 120, 222, 108, 139, 115]);
+      const uBytes = new Uint8Array([131, 242, 143, 160, 87, 2, 138, 134, 79, 253, 189, 173, 224, 73, 144, 241, 190, 81, 197, 15, 249, 105, 145, 151, 15, 194, 65, 3, 1, 126, 187, 221, 117, 169, 4, 32, 159, 101, 22, 220, 168, 94, 215, 192, 100, 38, 188, 40]);
+      const result = alg.checkOwnerPassword(password, ownerValidation, uBytes, ownerPassword);
       expect(result).toEqual(true);
     });
     it("should generate a file encryption key from the user key", function () {
-      var password, userKeySalt, expected, alg, result, userEncryption;
-      alg = new _crypto.PDF17();
-      password = new Uint8Array([117, 115, 101, 114]);
-      userKeySalt = new Uint8Array([168, 94, 215, 192, 100, 38, 188, 40]);
-      userEncryption = new Uint8Array([35, 150, 195, 169, 245, 51, 51, 255, 158, 158, 33, 242, 231, 75, 125, 190, 25, 126, 172, 114, 195, 244, 137, 245, 234, 165, 42, 74, 60, 38, 17, 17]);
-      result = alg.getUserKey(password, userKeySalt, userEncryption);
-      expected = new Uint8Array([63, 114, 136, 209, 87, 61, 12, 30, 249, 1, 186, 144, 254, 248, 163, 153, 151, 51, 133, 10, 80, 152, 206, 15, 72, 187, 231, 33, 224, 239, 13, 213]);
+      const alg = new _crypto.PDF17();
+      const password = new Uint8Array([117, 115, 101, 114]);
+      const userKeySalt = new Uint8Array([168, 94, 215, 192, 100, 38, 188, 40]);
+      const userEncryption = new Uint8Array([35, 150, 195, 169, 245, 51, 51, 255, 158, 158, 33, 242, 231, 75, 125, 190, 25, 126, 172, 114, 195, 244, 137, 245, 234, 165, 42, 74, 60, 38, 17, 17]);
+      const result = alg.getUserKey(password, userKeySalt, userEncryption);
+      const expected = new Uint8Array([63, 114, 136, 209, 87, 61, 12, 30, 249, 1, 186, 144, 254, 248, 163, 153, 151, 51, 133, 10, 80, 152, 206, 15, 72, 187, 231, 33, 224, 239, 13, 213]);
       expect(result).toEqual(expected);
     });
     it("should generate a file encryption key from the owner key", function () {
-      var password, ownerKeySalt, expected, alg, result, ownerEncryption;
-      var uBytes;
-      alg = new _crypto.PDF17();
-      password = new Uint8Array([111, 119, 110, 101, 114]);
-      ownerKeySalt = new Uint8Array([200, 245, 242, 12, 218, 123, 24, 120]);
-      ownerEncryption = new Uint8Array([213, 202, 14, 189, 110, 76, 70, 191, 6, 195, 10, 190, 157, 100, 144, 85, 8, 62, 123, 178, 156, 229, 50, 40, 229, 216, 54, 222, 34, 38, 106, 223]);
-      uBytes = new Uint8Array([131, 242, 143, 160, 87, 2, 138, 134, 79, 253, 189, 173, 224, 73, 144, 241, 190, 81, 197, 15, 249, 105, 145, 151, 15, 194, 65, 3, 1, 126, 187, 221, 117, 169, 4, 32, 159, 101, 22, 220, 168, 94, 215, 192, 100, 38, 188, 40]);
-      result = alg.getOwnerKey(password, ownerKeySalt, uBytes, ownerEncryption);
-      expected = new Uint8Array([63, 114, 136, 209, 87, 61, 12, 30, 249, 1, 186, 144, 254, 248, 163, 153, 151, 51, 133, 10, 80, 152, 206, 15, 72, 187, 231, 33, 224, 239, 13, 213]);
+      const alg = new _crypto.PDF17();
+      const password = new Uint8Array([111, 119, 110, 101, 114]);
+      const ownerKeySalt = new Uint8Array([200, 245, 242, 12, 218, 123, 24, 120]);
+      const ownerEncryption = new Uint8Array([213, 202, 14, 189, 110, 76, 70, 191, 6, 195, 10, 190, 157, 100, 144, 85, 8, 62, 123, 178, 156, 229, 50, 40, 229, 216, 54, 222, 34, 38, 106, 223]);
+      const uBytes = new Uint8Array([131, 242, 143, 160, 87, 2, 138, 134, 79, 253, 189, 173, 224, 73, 144, 241, 190, 81, 197, 15, 249, 105, 145, 151, 15, 194, 65, 3, 1, 126, 187, 221, 117, 169, 4, 32, 159, 101, 22, 220, 168, 94, 215, 192, 100, 38, 188, 40]);
+      const result = alg.getOwnerKey(password, ownerKeySalt, uBytes, ownerEncryption);
+      const expected = new Uint8Array([63, 114, 136, 209, 87, 61, 12, 30, 249, 1, 186, 144, 254, 248, 163, 153, 151, 51, 133, 10, 80, 152, 206, 15, 72, 187, 231, 33, 224, 239, 13, 213]);
       expect(result).toEqual(expected);
     });
   });
   describe("PDF20Algorithm", function () {
     it("should correctly check a user key", function () {
-      var password, userValidation, userPassword, alg, result;
-      alg = new _crypto.PDF20();
-      password = new Uint8Array([117, 115, 101, 114]);
-      userValidation = new Uint8Array([83, 245, 146, 101, 198, 247, 34, 198]);
-      userPassword = new Uint8Array([94, 230, 205, 75, 166, 99, 250, 76, 219, 128, 17, 85, 57, 17, 33, 164, 150, 46, 103, 176, 160, 156, 187, 233, 166, 223, 163, 253, 147, 235, 95, 184]);
-      result = alg.checkUserPassword(password, userValidation, userPassword);
+      const alg = new _crypto.PDF20();
+      const password = new Uint8Array([117, 115, 101, 114]);
+      const userValidation = new Uint8Array([83, 245, 146, 101, 198, 247, 34, 198]);
+      const userPassword = new Uint8Array([94, 230, 205, 75, 166, 99, 250, 76, 219, 128, 17, 85, 57, 17, 33, 164, 150, 46, 103, 176, 160, 156, 187, 233, 166, 223, 163, 253, 147, 235, 95, 184]);
+      const result = alg.checkUserPassword(password, userValidation, userPassword);
       expect(result).toEqual(true);
     });
     it("should correctly check an owner key", function () {
-      var password, ownerValidation, ownerPassword, alg, result, uBytes;
-      alg = new _crypto.PDF20();
-      password = new Uint8Array([111, 119, 110, 101, 114]);
-      ownerValidation = new Uint8Array([142, 232, 169, 208, 202, 214, 5, 185]);
-      ownerPassword = new Uint8Array([88, 232, 62, 54, 245, 26, 245, 209, 137, 123, 221, 72, 199, 49, 37, 217, 31, 74, 115, 167, 127, 158, 176, 77, 45, 163, 87, 47, 39, 90, 217, 141]);
-      uBytes = new Uint8Array([94, 230, 205, 75, 166, 99, 250, 76, 219, 128, 17, 85, 57, 17, 33, 164, 150, 46, 103, 176, 160, 156, 187, 233, 166, 223, 163, 253, 147, 235, 95, 184, 83, 245, 146, 101, 198, 247, 34, 198, 191, 11, 16, 94, 237, 216, 20, 175]);
-      result = alg.checkOwnerPassword(password, ownerValidation, uBytes, ownerPassword);
+      const alg = new _crypto.PDF20();
+      const password = new Uint8Array([111, 119, 110, 101, 114]);
+      const ownerValidation = new Uint8Array([142, 232, 169, 208, 202, 214, 5, 185]);
+      const ownerPassword = new Uint8Array([88, 232, 62, 54, 245, 26, 245, 209, 137, 123, 221, 72, 199, 49, 37, 217, 31, 74, 115, 167, 127, 158, 176, 77, 45, 163, 87, 47, 39, 90, 217, 141]);
+      const uBytes = new Uint8Array([94, 230, 205, 75, 166, 99, 250, 76, 219, 128, 17, 85, 57, 17, 33, 164, 150, 46, 103, 176, 160, 156, 187, 233, 166, 223, 163, 253, 147, 235, 95, 184, 83, 245, 146, 101, 198, 247, 34, 198, 191, 11, 16, 94, 237, 216, 20, 175]);
+      const result = alg.checkOwnerPassword(password, ownerValidation, uBytes, ownerPassword);
       expect(result).toEqual(true);
     });
     it("should generate a file encryption key from the user key", function () {
-      var password, userKeySalt, expected, alg, result, userEncryption;
-      alg = new _crypto.PDF20();
-      password = new Uint8Array([117, 115, 101, 114]);
-      userKeySalt = new Uint8Array([191, 11, 16, 94, 237, 216, 20, 175]);
-      userEncryption = new Uint8Array([121, 208, 2, 181, 230, 89, 156, 60, 253, 143, 212, 28, 84, 180, 196, 177, 173, 128, 221, 107, 46, 20, 94, 186, 135, 51, 95, 24, 20, 223, 254, 36]);
-      result = alg.getUserKey(password, userKeySalt, userEncryption);
-      expected = new Uint8Array([42, 218, 213, 39, 73, 91, 72, 79, 67, 38, 248, 133, 18, 189, 61, 34, 107, 79, 29, 56, 59, 181, 213, 118, 113, 34, 65, 210, 87, 174, 22, 239]);
+      const alg = new _crypto.PDF20();
+      const password = new Uint8Array([117, 115, 101, 114]);
+      const userKeySalt = new Uint8Array([191, 11, 16, 94, 237, 216, 20, 175]);
+      const userEncryption = new Uint8Array([121, 208, 2, 181, 230, 89, 156, 60, 253, 143, 212, 28, 84, 180, 196, 177, 173, 128, 221, 107, 46, 20, 94, 186, 135, 51, 95, 24, 20, 223, 254, 36]);
+      const result = alg.getUserKey(password, userKeySalt, userEncryption);
+      const expected = new Uint8Array([42, 218, 213, 39, 73, 91, 72, 79, 67, 38, 248, 133, 18, 189, 61, 34, 107, 79, 29, 56, 59, 181, 213, 118, 113, 34, 65, 210, 87, 174, 22, 239]);
       expect(result).toEqual(expected);
     });
     it("should generate a file encryption key from the owner key", function () {
-      var password, ownerKeySalt, expected, alg, result, ownerEncryption;
-      var uBytes;
-      alg = new _crypto.PDF20();
-      password = new Uint8Array([111, 119, 110, 101, 114]);
-      ownerKeySalt = new Uint8Array([29, 208, 185, 46, 11, 76, 135, 149]);
-      ownerEncryption = new Uint8Array([209, 73, 224, 77, 103, 155, 201, 181, 190, 68, 223, 20, 62, 90, 56, 210, 5, 240, 178, 128, 238, 124, 68, 254, 253, 244, 62, 108, 208, 135, 10, 251]);
-      uBytes = new Uint8Array([94, 230, 205, 75, 166, 99, 250, 76, 219, 128, 17, 85, 57, 17, 33, 164, 150, 46, 103, 176, 160, 156, 187, 233, 166, 223, 163, 253, 147, 235, 95, 184, 83, 245, 146, 101, 198, 247, 34, 198, 191, 11, 16, 94, 237, 216, 20, 175]);
-      result = alg.getOwnerKey(password, ownerKeySalt, uBytes, ownerEncryption);
-      expected = new Uint8Array([42, 218, 213, 39, 73, 91, 72, 79, 67, 38, 248, 133, 18, 189, 61, 34, 107, 79, 29, 56, 59, 181, 213, 118, 113, 34, 65, 210, 87, 174, 22, 239]);
+      const alg = new _crypto.PDF20();
+      const password = new Uint8Array([111, 119, 110, 101, 114]);
+      const ownerKeySalt = new Uint8Array([29, 208, 185, 46, 11, 76, 135, 149]);
+      const ownerEncryption = new Uint8Array([209, 73, 224, 77, 103, 155, 201, 181, 190, 68, 223, 20, 62, 90, 56, 210, 5, 240, 178, 128, 238, 124, 68, 254, 253, 244, 62, 108, 208, 135, 10, 251]);
+      const uBytes = new Uint8Array([94, 230, 205, 75, 166, 99, 250, 76, 219, 128, 17, 85, 57, 17, 33, 164, 150, 46, 103, 176, 160, 156, 187, 233, 166, 223, 163, 253, 147, 235, 95, 184, 83, 245, 146, 101, 198, 247, 34, 198, 191, 11, 16, 94, 237, 216, 20, 175]);
+      const result = alg.getOwnerKey(password, ownerKeySalt, uBytes, ownerEncryption);
+      const expected = new Uint8Array([42, 218, 213, 39, 73, 91, 72, 79, 67, 38, 248, 133, 18, 189, 61, 34, 107, 79, 29, 56, 59, 181, 213, 118, 113, 34, 65, 210, 87, 174, 22, 239]);
       expect(result).toEqual(expected);
     });
   });
 });
 describe("CipherTransformFactory", function () {
   function buildDict(map) {
-    var dict = new _primitives.Dict();
+    const dict = new _primitives.Dict();
 
-    for (var key in map) {
+    for (const key in map) {
       dict.set(key, map[key]);
     }
 
@@ -370,7 +333,7 @@ describe("CipherTransformFactory", function () {
 
   function ensurePasswordCorrect(done, dict, fileId, password) {
     try {
-      var factory = new _crypto.CipherTransformFactory(dict, fileId, password);
+      const factory = new _crypto.CipherTransformFactory(dict, fileId, password);
       expect("createCipherTransform" in factory).toEqual(true);
     } catch (ex) {
       done.fail("Password should be accepted: " + ex);
@@ -414,8 +377,8 @@ describe("CipherTransformFactory", function () {
     expect(string).toEqual(decrypted);
   }
 
-  var fileId1, fileId2, dict1, dict2, dict3;
-  var aes256Dict, aes256IsoDict, aes256BlankDict, aes256IsoBlankDict;
+  let fileId1, fileId2, dict1, dict2, dict3;
+  let aes256Dict, aes256IsoDict, aes256BlankDict, aes256IsoBlankDict;
   beforeAll(function (done) {
     fileId1 = unescape("%F6%C6%AF%17%F3rR%8DRM%9A%80%D1%EF%DF%18");
     fileId2 = unescape("%3CL_%3AD%96%AF@%9A%9D%B3%3Cx%1Cv%AC");

package/lib/test/unit/custom_spec.js

@@ -21,15 +21,9 @@
  */
 "use strict";
 
-var _test_utils = require("./test_utils.js");
-
-var _display_utils = require("../../display/display_utils.js");
-
 var _api = require("../../display/api.js");
 
-var _is_node = require("../../shared/is_node.js");
-
-var _node_utils = require("../../display/node_utils.js");
+var _test_utils = require("./test_utils.js");
 
 function getTopLeftPixel(canvasContext) {
   const imgData = canvasContext.getImageData(0, 0, 1, 1);
@@ -47,12 +41,7 @@ describe("custom canvas rendering", function () {
   let loadingTask;
   let page;
   beforeAll(function (done) {
-    if (_is_node.isNodeJS) {
-      CanvasFactory = new _node_utils.NodeCanvasFactory();
-    } else {
-      CanvasFactory = new _display_utils.DOMCanvasFactory();
-    }
-
+    CanvasFactory = new _api.DefaultCanvasFactory();
     loadingTask = (0, _api.getDocument)(transparentGetDocumentParams);
     loadingTask.promise.then(function (doc) {
       return doc.getPage(1);
@@ -67,10 +56,10 @@ describe("custom canvas rendering", function () {
     loadingTask.destroy().then(done);
   });
   it("renders to canvas with a default white background", function (done) {
-    var viewport = page.getViewport({
+    const viewport = page.getViewport({
       scale: 1
     });
-    var canvasAndCtx = CanvasFactory.create(viewport.width, viewport.height);
+    const canvasAndCtx = CanvasFactory.create(viewport.width, viewport.height);
     const renderTask = page.render({
       canvasContext: canvasAndCtx.context,
       viewport
@@ -87,10 +76,10 @@ describe("custom canvas rendering", function () {
     }).catch(done.fail);
   });
   it("renders to canvas with a custom background", function (done) {
-    var viewport = page.getViewport({
+    const viewport = page.getViewport({
       scale: 1
     });
-    var canvasAndCtx = CanvasFactory.create(viewport.width, viewport.height);
+    const canvasAndCtx = CanvasFactory.create(viewport.width, viewport.height);
     const renderTask = page.render({
       canvasContext: canvasAndCtx.context,
       viewport,
@@ -163,7 +152,7 @@ describe("custom ownerDocument", function () {
         }]
       }
     };
-    const CanvasFactory = _is_node.isNodeJS ? new _node_utils.NodeCanvasFactory() : new _display_utils.DOMCanvasFactory({
+    const CanvasFactory = new _api.DefaultCanvasFactory({
       ownerDocument
     });
     return {