Merge pull request #13321 from timvandermeij/src-core-no-var
Enable the `no-var` linting rule in `src/core/{crypto,function}.js`
This commit is contained in:
Tim van der Meij
GitHub
commit
af9feb1307
@ -12,7 +12,6 @@
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
/* eslint-disable no-var */
|
||||
|
||||
import {
|
||||
bytesToString,
|
||||
@ -32,16 +31,14 @@ class ARCFourCipher {
|
||||
constructor(key) {
|
||||
this.a = 0;
|
||||
this.b = 0;
|
||||
var s = new Uint8Array(256);
|
||||
var i,
|
||||
j = 0,
|
||||
tmp,
|
||||
keyLength = key.length;
|
||||
for (i = 0; i < 256; ++i) {
|
||||
const s = new Uint8Array(256);
|
||||
const keyLength = key.length;
|
||||
|
||||
for (let i = 0; i < 256; ++i) {
|
||||
s[i] = i;
|
||||
}
|
||||
for (i = 0; i < 256; ++i) {
|
||||
tmp = s[i];
|
||||
for (let i = 0, j = 0; i < 256; ++i) {
|
||||
const tmp = s[i];
|
||||
j = (j + tmp + key[i % keyLength]) & 0xff;
|
||||
s[i] = s[j];
|
||||
s[j] = tmp;
|
||||
@ -50,19 +47,16 @@ class ARCFourCipher {
|
||||
}
|
||||
|
||||
encryptBlock(data) {
|
||||
var i,
|
||||
n = data.length,
|
||||
tmp,
|
||||
tmp2;
|
||||
var a = this.a,
|
||||
b = this.b,
|
||||
s = this.s;
|
||||
var output = new Uint8Array(n);
|
||||
for (i = 0; i < n; ++i) {
|
||||
let a = this.a,
|
||||
b = this.b;
|
||||
const s = this.s;
|
||||
const n = data.length;
|
||||
const output = new Uint8Array(n);
|
||||
for (let i = 0; i < n; ++i) {
|
||||
a = (a + 1) & 0xff;
|
||||
tmp = s[a];
|
||||
const tmp = s[a];
|
||||
b = (b + tmp) & 0xff;
|
||||
tmp2 = s[b];
|
||||
const tmp2 = s[b];
|
||||
s[a] = tmp2;
|
||||
s[b] = tmp;
|
||||
output[i] = data[i] ^ s[(tmp + tmp2) & 0xff];
|
||||
@ -81,16 +75,16 @@ class ARCFourCipher {
|
||||
}
|
||||
}
|
||||
|
||||
var calculateMD5 = (function calculateMD5Closure() {
|
||||
const calculateMD5 = (function calculateMD5Closure() {
|
||||
// prettier-ignore
|
||||
var r = new Uint8Array([
|
||||
const r = new Uint8Array([
|
||||
7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
|
||||
5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20,
|
||||
4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
|
||||
6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21]);
|
||||
|
||||
// prettier-ignore
|
||||
var k = new Int32Array([
|
||||
const k = new Int32Array([
|
||||
-680876936, -389564586, 606105819, -1044525330, -176418897, 1200080426,
|
||||
-1473231341, -45705983, 1770035416, -1958414417, -42063, -1990404162,
|
||||
1804603682, -40341101, -1502002290, 1236535329, -165796510, -1069501632,
|
||||
@ -104,19 +98,19 @@ var calculateMD5 = (function calculateMD5Closure() {
|
||||
-145523070, -1120210379, 718787259, -343485551]);
|
||||
|
||||
function hash(data, offset, length) {
|
||||
var h0 = 1732584193,
|
||||
let h0 = 1732584193,
|
||||
h1 = -271733879,
|
||||
h2 = -1732584194,
|
||||
h3 = 271733878;
|
||||
// pre-processing
|
||||
var paddedLength = (length + 72) & ~63; // data + 9 extra bytes
|
||||
var padded = new Uint8Array(paddedLength);
|
||||
var i, j, n;
|
||||
const paddedLength = (length + 72) & ~63; // data + 9 extra bytes
|
||||
const padded = new Uint8Array(paddedLength);
|
||||
let i, j;
|
||||
for (i = 0; i < length; ++i) {
|
||||
padded[i] = data[offset++];
|
||||
}
|
||||
padded[i++] = 0x80;
|
||||
n = paddedLength - 8;
|
||||
const n = paddedLength - 8;
|
||||
while (i < n) {
|
||||
padded[i++] = 0;
|
||||
}
|
||||
@ -128,7 +122,7 @@ var calculateMD5 = (function calculateMD5Closure() {
|
||||
padded[i++] = 0;
|
||||
padded[i++] = 0;
|
||||
padded[i++] = 0;
|
||||
var w = new Int32Array(16);
|
||||
const w = new Int32Array(16);
|
||||
for (i = 0; i < paddedLength; ) {
|
||||
for (j = 0; j < 16; ++j, i += 4) {
|
||||
w[j] =
|
||||
@ -137,7 +131,7 @@ var calculateMD5 = (function calculateMD5Closure() {
|
||||
(padded[i + 2] << 16) |
|
||||
(padded[i + 3] << 24);
|
||||
}
|
||||
var a = h0,
|
||||
let a = h0,
|
||||
b = h1,
|
||||
c = h2,
|
||||
d = h3,
|
||||
@ -157,7 +151,7 @@ var calculateMD5 = (function calculateMD5Closure() {
|
||||
f = c ^ (b | ~d);
|
||||
g = (7 * j) & 15;
|
||||
}
|
||||
var tmp = d,
|
||||
const tmp = d,
|
||||
rotateArg = (a + f + k[j] + w[g]) | 0,
|
||||
rotate = r[j];
|
||||
d = c;
|
||||
@ -224,7 +218,7 @@ class Word64 {
|
||||
}
|
||||
|
||||
rotateRight(places) {
|
||||
var low, high;
|
||||
let low, high;
|
||||
if (places & 32) {
|
||||
high = this.low;
|
||||
low = this.high;
|
||||
@ -243,8 +237,8 @@ class Word64 {
|
||||
}
|
||||
|
||||
add(word) {
|
||||
var lowAdd = (this.low >>> 0) + (word.low >>> 0);
|
||||
var highAdd = (this.high >>> 0) + (word.high >>> 0);
|
||||
const lowAdd = (this.low >>> 0) + (word.low >>> 0);
|
||||
let highAdd = (this.high >>> 0) + (word.high >>> 0);
|
||||
if (lowAdd > 0xffffffff) {
|
||||
highAdd += 1;
|
||||
}
|
||||
@ -269,7 +263,7 @@ class Word64 {
|
||||
}
|
||||
}
|
||||
|
||||
var calculateSHA256 = (function calculateSHA256Closure() {
|
||||
const calculateSHA256 = (function calculateSHA256Closure() {
|
||||
function rotr(x, n) {
|
||||
return (x >>> n) | (x << (32 - n));
|
||||
}
|
||||
@ -299,7 +293,7 @@ var calculateSHA256 = (function calculateSHA256Closure() {
|
||||
}
|
||||
|
||||
// prettier-ignore
|
||||
var k = [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
|
||||
const k = [0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
|
||||
0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
|
||||
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
|
||||
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
|
||||
@ -318,7 +312,7 @@ var calculateSHA256 = (function calculateSHA256Closure() {
|
||||
|
||||
function hash(data, offset, length) {
|
||||
// initial hash values
|
||||
var h0 = 0x6a09e667,
|
||||
let h0 = 0x6a09e667,
|
||||
h1 = 0xbb67ae85,
|
||||
h2 = 0x3c6ef372,
|
||||
h3 = 0xa54ff53a,
|
||||
@ -327,14 +321,14 @@ var calculateSHA256 = (function calculateSHA256Closure() {
|
||||
h6 = 0x1f83d9ab,
|
||||
h7 = 0x5be0cd19;
|
||||
// pre-processing
|
||||
var paddedLength = Math.ceil((length + 9) / 64) * 64;
|
||||
var padded = new Uint8Array(paddedLength);
|
||||
var i, j, n;
|
||||
const paddedLength = Math.ceil((length + 9) / 64) * 64;
|
||||
const padded = new Uint8Array(paddedLength);
|
||||
let i, j;
|
||||
for (i = 0; i < length; ++i) {
|
||||
padded[i] = data[offset++];
|
||||
}
|
||||
padded[i++] = 0x80;
|
||||
n = paddedLength - 8;
|
||||
const n = paddedLength - 8;
|
||||
while (i < n) {
|
||||
padded[i++] = 0;
|
||||
}
|
||||
@ -346,7 +340,7 @@ var calculateSHA256 = (function calculateSHA256Closure() {
|
||||
padded[i++] = (length >> 13) & 0xff;
|
||||
padded[i++] = (length >> 5) & 0xff;
|
||||
padded[i++] = (length << 3) & 0xff;
|
||||
var w = new Uint32Array(64);
|
||||
const w = new Uint32Array(64);
|
||||
// for each 512 bit block
|
||||
for (i = 0; i < paddedLength; ) {
|
||||
for (j = 0; j < 16; ++j) {
|
||||
@ -366,7 +360,7 @@ var calculateSHA256 = (function calculateSHA256Closure() {
|
||||
w[j - 16]) |
|
||||
0;
|
||||
}
|
||||
var a = h0,
|
||||
let a = h0,
|
||||
b = h1,
|
||||
c = h2,
|
||||
d = h3,
|
||||
@ -413,7 +407,7 @@ var calculateSHA256 = (function calculateSHA256Closure() {
|
||||
return hash;
|
||||
})();
|
||||
|
||||
var calculateSHA512 = (function calculateSHA512Closure() {
|
||||
const calculateSHA512 = (function calculateSHA512Closure() {
|
||||
function ch(result, x, y, z, tmp) {
|
||||
result.assign(x);
|
||||
result.and(y);
|
||||
@ -479,7 +473,7 @@ var calculateSHA512 = (function calculateSHA512Closure() {
|
||||
}
|
||||
|
||||
// prettier-ignore
|
||||
var k = [
|
||||
const k = [
|
||||
new Word64(0x428a2f98, 0xd728ae22), new Word64(0x71374491, 0x23ef65cd),
|
||||
new Word64(0xb5c0fbcf, 0xec4d3b2f), new Word64(0xe9b5dba5, 0x8189dbbc),
|
||||
new Word64(0x3956c25b, 0xf348b538), new Word64(0x59f111f1, 0xb605d019),
|
||||
@ -523,7 +517,7 @@ var calculateSHA512 = (function calculateSHA512Closure() {
|
||||
|
||||
function hash(data, offset, length, mode384 = false) {
|
||||
// initial hash values
|
||||
var h0, h1, h2, h3, h4, h5, h6, h7;
|
||||
let h0, h1, h2, h3, h4, h5, h6, h7;
|
||||
if (!mode384) {
|
||||
h0 = new Word64(0x6a09e667, 0xf3bcc908);
|
||||
h1 = new Word64(0xbb67ae85, 0x84caa73b);
|
||||
@ -547,14 +541,14 @@ var calculateSHA512 = (function calculateSHA512Closure() {
|
||||
}
|
||||
|
||||
// pre-processing
|
||||
var paddedLength = Math.ceil((length + 17) / 128) * 128;
|
||||
var padded = new Uint8Array(paddedLength);
|
||||
var i, j, n;
|
||||
const paddedLength = Math.ceil((length + 17) / 128) * 128;
|
||||
const padded = new Uint8Array(paddedLength);
|
||||
let i, j;
|
||||
for (i = 0; i < length; ++i) {
|
||||
padded[i] = data[offset++];
|
||||
}
|
||||
padded[i++] = 0x80;
|
||||
n = paddedLength - 16;
|
||||
const n = paddedLength - 16;
|
||||
while (i < n) {
|
||||
padded[i++] = 0;
|
||||
}
|
||||
@ -575,23 +569,23 @@ var calculateSHA512 = (function calculateSHA512Closure() {
|
||||
padded[i++] = (length >> 5) & 0xff;
|
||||
padded[i++] = (length << 3) & 0xff;
|
||||
|
||||
var w = new Array(80);
|
||||
const w = new Array(80);
|
||||
for (i = 0; i < 80; i++) {
|
||||
w[i] = new Word64(0, 0);
|
||||
}
|
||||
var a = new Word64(0, 0),
|
||||
let a = new Word64(0, 0),
|
||||
b = new Word64(0, 0),
|
||||
c = new Word64(0, 0);
|
||||
var d = new Word64(0, 0),
|
||||
let d = new Word64(0, 0),
|
||||
e = new Word64(0, 0),
|
||||
f = new Word64(0, 0);
|
||||
var g = new Word64(0, 0),
|
||||
let g = new Word64(0, 0),
|
||||
h = new Word64(0, 0);
|
||||
var t1 = new Word64(0, 0),
|
||||
const t1 = new Word64(0, 0),
|
||||
t2 = new Word64(0, 0);
|
||||
var tmp1 = new Word64(0, 0),
|
||||
tmp2 = new Word64(0, 0),
|
||||
tmp3;
|
||||
const tmp1 = new Word64(0, 0),
|
||||
tmp2 = new Word64(0, 0);
|
||||
let tmp3;
|
||||
|
||||
// for each 1024 bit block
|
||||
for (i = 0; i < paddedLength; ) {
|
||||
@ -661,7 +655,7 @@ var calculateSHA512 = (function calculateSHA512Closure() {
|
||||
h7.add(h);
|
||||
}
|
||||
|
||||
var result;
|
||||
let result;
|
||||
if (!mode384) {
|
||||
result = new Uint8Array(64);
|
||||
h0.copyTo(result, 0);
|
||||
@ -1255,49 +1249,49 @@ class AES256Cipher extends AESBaseCipher {
|
||||
|
||||
class PDF17 {
|
||||
checkOwnerPassword(password, ownerValidationSalt, userBytes, ownerPassword) {
|
||||
var hashData = new Uint8Array(password.length + 56);
|
||||
const 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);
|
||||
const result = calculateSHA256(hashData, 0, hashData.length);
|
||||
return isArrayEqual(result, ownerPassword);
|
||||
}
|
||||
|
||||
checkUserPassword(password, userValidationSalt, userPassword) {
|
||||
var hashData = new Uint8Array(password.length + 8);
|
||||
const hashData = new Uint8Array(password.length + 8);
|
||||
hashData.set(password, 0);
|
||||
hashData.set(userValidationSalt, password.length);
|
||||
var result = calculateSHA256(hashData, 0, hashData.length);
|
||||
const result = calculateSHA256(hashData, 0, hashData.length);
|
||||
return isArrayEqual(result, userPassword);
|
||||
}
|
||||
|
||||
getOwnerKey(password, ownerKeySalt, userBytes, ownerEncryption) {
|
||||
var hashData = new Uint8Array(password.length + 56);
|
||||
const 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);
|
||||
const key = calculateSHA256(hashData, 0, hashData.length);
|
||||
const cipher = new AES256Cipher(key);
|
||||
return cipher.decryptBlock(ownerEncryption, false, new Uint8Array(16));
|
||||
}
|
||||
|
||||
getUserKey(password, userKeySalt, userEncryption) {
|
||||
var hashData = new Uint8Array(password.length + 8);
|
||||
const 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);
|
||||
const key = calculateSHA256(hashData, 0, hashData.length);
|
||||
const cipher = new AES256Cipher(key);
|
||||
return cipher.decryptBlock(userEncryption, false, new Uint8Array(16));
|
||||
}
|
||||
}
|
||||
|
||||
var PDF20 = (function PDF20Closure() {
|
||||
const PDF20 = (function PDF20Closure() {
|
||||
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;
|
||||
let k = calculateSHA256(input, 0, input.length).subarray(0, 32);
|
||||
let e = [0];
|
||||
let i = 0;
|
||||
while (i < 64 || e[e.length - 1] > i - 32) {
|
||||
const combinedLength = password.length + k.length + userBytes.length,
|
||||
combinedArray = new Uint8Array(combinedLength);
|
||||
@ -1308,20 +1302,20 @@ var PDF20 = (function PDF20Closure() {
|
||||
writeOffset += k.length;
|
||||
combinedArray.set(userBytes, writeOffset);
|
||||
|
||||
var k1 = new Uint8Array(combinedLength * 64);
|
||||
for (var j = 0, pos = 0; j < 64; j++, pos += combinedLength) {
|
||||
const k1 = new Uint8Array(combinedLength * 64);
|
||||
for (let j = 0, pos = 0; j < 64; j++, pos += combinedLength) {
|
||||
k1.set(combinedArray, 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));
|
||||
const 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++) {
|
||||
let remainder = 0;
|
||||
for (let z = 0; z < 16; z++) {
|
||||
remainder *= 256 % 3;
|
||||
remainder %= 3;
|
||||
remainder += (e[z] >>> 0) % 3;
|
||||
@ -1351,39 +1345,39 @@ var PDF20 = (function PDF20Closure() {
|
||||
userBytes,
|
||||
ownerPassword
|
||||
) {
|
||||
var hashData = new Uint8Array(password.length + 56);
|
||||
const 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);
|
||||
const result = calculatePDF20Hash(password, hashData, userBytes);
|
||||
return isArrayEqual(result, ownerPassword);
|
||||
}
|
||||
|
||||
checkUserPassword(password, userValidationSalt, userPassword) {
|
||||
var hashData = new Uint8Array(password.length + 8);
|
||||
const hashData = new Uint8Array(password.length + 8);
|
||||
hashData.set(password, 0);
|
||||
hashData.set(userValidationSalt, password.length);
|
||||
var result = calculatePDF20Hash(password, hashData, []);
|
||||
const result = calculatePDF20Hash(password, hashData, []);
|
||||
return isArrayEqual(result, userPassword);
|
||||
}
|
||||
|
||||
getOwnerKey(password, ownerKeySalt, userBytes, ownerEncryption) {
|
||||
var hashData = new Uint8Array(password.length + 56);
|
||||
const 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);
|
||||
const key = calculatePDF20Hash(password, hashData, userBytes);
|
||||
const cipher = new AES256Cipher(key);
|
||||
return cipher.decryptBlock(ownerEncryption, false, new Uint8Array(16));
|
||||
}
|
||||
|
||||
getUserKey(password, userKeySalt, userEncryption) {
|
||||
var hashData = new Uint8Array(password.length + 8);
|
||||
const 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);
|
||||
const key = calculatePDF20Hash(password, hashData, []);
|
||||
const cipher = new AES256Cipher(key);
|
||||
return cipher.decryptBlock(userEncryption, false, new Uint8Array(16));
|
||||
}
|
||||
}
|
||||
@ -1398,7 +1392,7 @@ class CipherTransform {
|
||||
}
|
||||
|
||||
createStream(stream, length) {
|
||||
var cipher = new this.StreamCipherConstructor();
|
||||
const cipher = new this.StreamCipherConstructor();
|
||||
return new DecryptStream(
|
||||
stream,
|
||||
length,
|
||||
@ -1409,8 +1403,8 @@ class CipherTransform {
|
||||
}
|
||||
|
||||
decryptString(s) {
|
||||
var cipher = new this.StringCipherConstructor();
|
||||
var data = stringToBytes(s);
|
||||
const cipher = new this.StringCipherConstructor();
|
||||
let data = stringToBytes(s);
|
||||
data = cipher.decryptBlock(data, true);
|
||||
return bytesToString(data);
|
||||
}
|
||||
@ -1453,9 +1447,9 @@ class CipherTransform {
|
||||
}
|
||||
}
|
||||
|
||||
var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
const CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
// prettier-ignore
|
||||
var defaultPasswordBytes = new Uint8Array([
|
||||
const 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,
|
||||
@ -1476,12 +1470,12 @@ var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
perms
|
||||
) {
|
||||
if (password) {
|
||||
var passwordLength = Math.min(127, password.length);
|
||||
const passwordLength = Math.min(127, password.length);
|
||||
password = password.subarray(0, passwordLength);
|
||||
} else {
|
||||
password = [];
|
||||
}
|
||||
var pdfAlgorithm;
|
||||
let pdfAlgorithm;
|
||||
if (revision === 6) {
|
||||
pdfAlgorithm = new PDF20();
|
||||
} else {
|
||||
@ -1522,9 +1516,9 @@ var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
keyLength,
|
||||
encryptMetadata
|
||||
) {
|
||||
var hashDataSize = 40 + ownerPassword.length + fileId.length;
|
||||
var hashData = new Uint8Array(hashDataSize),
|
||||
i = 0,
|
||||
const hashDataSize = 40 + ownerPassword.length + fileId.length;
|
||||
const hashData = new Uint8Array(hashDataSize);
|
||||
let i = 0,
|
||||
j,
|
||||
n;
|
||||
if (password) {
|
||||
@ -1554,15 +1548,15 @@ var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
hashData[i++] = 0xff;
|
||||
hashData[i++] = 0xff;
|
||||
}
|
||||
var hash = calculateMD5(hashData, 0, i);
|
||||
var keyLengthInBytes = keyLength >> 3;
|
||||
let hash = calculateMD5(hashData, 0, i);
|
||||
const 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;
|
||||
const encryptionKey = hash.subarray(0, keyLengthInBytes);
|
||||
let cipher, checkData;
|
||||
|
||||
if (revision >= 3) {
|
||||
for (i = 0; i < 32; ++i) {
|
||||
@ -1574,10 +1568,9 @@ var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
cipher = new ARCFourCipher(encryptionKey);
|
||||
checkData = cipher.encryptBlock(calculateMD5(hashData, 0, i));
|
||||
n = encryptionKey.length;
|
||||
var derivedKey = new Uint8Array(n),
|
||||
k;
|
||||
const derivedKey = new Uint8Array(n);
|
||||
for (j = 1; j <= 19; ++j) {
|
||||
for (k = 0; k < n; ++k) {
|
||||
for (let k = 0; k < n; ++k) {
|
||||
derivedKey[k] = encryptionKey[k] ^ j;
|
||||
}
|
||||
cipher = new ARCFourCipher(derivedKey);
|
||||
@ -1601,33 +1594,30 @@ var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
}
|
||||
|
||||
function decodeUserPassword(password, ownerPassword, revision, keyLength) {
|
||||
var hashData = new Uint8Array(32),
|
||||
i = 0,
|
||||
j,
|
||||
n;
|
||||
n = Math.min(32, password.length);
|
||||
const hashData = new Uint8Array(32);
|
||||
let i = 0;
|
||||
const n = Math.min(32, password.length);
|
||||
for (; i < n; ++i) {
|
||||
hashData[i] = password[i];
|
||||
}
|
||||
j = 0;
|
||||
let j = 0;
|
||||
while (i < 32) {
|
||||
hashData[i++] = defaultPasswordBytes[j++];
|
||||
}
|
||||
var hash = calculateMD5(hashData, 0, i);
|
||||
var keyLengthInBytes = keyLength >> 3;
|
||||
let hash = calculateMD5(hashData, 0, i);
|
||||
const keyLengthInBytes = keyLength >> 3;
|
||||
if (revision >= 3) {
|
||||
for (j = 0; j < 50; ++j) {
|
||||
hash = calculateMD5(hash, 0, hash.length);
|
||||
}
|
||||
}
|
||||
|
||||
var cipher, userPassword;
|
||||
let cipher, userPassword;
|
||||
if (revision >= 3) {
|
||||
userPassword = ownerPassword;
|
||||
var derivedKey = new Uint8Array(keyLengthInBytes),
|
||||
k;
|
||||
const derivedKey = new Uint8Array(keyLengthInBytes);
|
||||
for (j = 19; j >= 0; j--) {
|
||||
for (k = 0; k < keyLengthInBytes; ++k) {
|
||||
for (let k = 0; k < keyLengthInBytes; ++k) {
|
||||
derivedKey[k] = hash[k] ^ j;
|
||||
}
|
||||
cipher = new ARCFourCipher(derivedKey);
|
||||
@ -1640,13 +1630,13 @@ var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
return userPassword;
|
||||
}
|
||||
|
||||
var identityName = Name.get("Identity");
|
||||
const identityName = Name.get("Identity");
|
||||
|
||||
function buildObjectKey(num, gen, encryptionKey, isAes = false) {
|
||||
var key = new Uint8Array(encryptionKey.length + 9),
|
||||
i,
|
||||
n;
|
||||
for (i = 0, n = encryptionKey.length; i < n; ++i) {
|
||||
const key = new Uint8Array(encryptionKey.length + 9);
|
||||
const n = encryptionKey.length;
|
||||
let i;
|
||||
for (i = 0; i < n; ++i) {
|
||||
key[i] = encryptionKey[i];
|
||||
}
|
||||
key[i++] = num & 0xff;
|
||||
@ -1660,7 +1650,7 @@ var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
key[i++] = 0x6c;
|
||||
key[i++] = 0x54;
|
||||
}
|
||||
var hash = calculateMD5(key, 0, i);
|
||||
const hash = calculateMD5(key, 0, i);
|
||||
return hash.subarray(0, Math.min(encryptionKey.length + 5, 16));
|
||||
}
|
||||
|
||||
@ -1668,8 +1658,8 @@ var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
if (!isName(name)) {
|
||||
throw new FormatError("Invalid crypt filter name.");
|
||||
}
|
||||
var cryptFilter = cf.get(name.name);
|
||||
var cfm;
|
||||
const cryptFilter = cf.get(name.name);
|
||||
let cfm;
|
||||
if (cryptFilter !== null && cryptFilter !== undefined) {
|
||||
cfm = cryptFilter.get("CFM");
|
||||
}
|
||||
@ -1703,12 +1693,12 @@ var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
// eslint-disable-next-line no-shadow
|
||||
class CipherTransformFactory {
|
||||
constructor(dict, fileId, password) {
|
||||
var filter = dict.get("Filter");
|
||||
const filter = dict.get("Filter");
|
||||
if (!isName(filter, "Standard")) {
|
||||
throw new FormatError("unknown encryption method");
|
||||
}
|
||||
this.dict = dict;
|
||||
var algorithm = dict.get("V");
|
||||
const algorithm = dict.get("V");
|
||||
if (
|
||||
!Number.isInteger(algorithm) ||
|
||||
(algorithm !== 1 &&
|
||||
@ -1719,7 +1709,7 @@ var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
throw new FormatError("unsupported encryption algorithm");
|
||||
}
|
||||
this.algorithm = algorithm;
|
||||
var keyLength = dict.get("Length");
|
||||
let keyLength = dict.get("Length");
|
||||
if (!keyLength) {
|
||||
// Spec asks to rely on encryption dictionary's Length entry, however
|
||||
// some PDFs don't have it. Trying to recover.
|
||||
@ -1728,11 +1718,11 @@ var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
keyLength = 40;
|
||||
} else {
|
||||
// Trying to find default handler -- it usually has Length.
|
||||
var cfDict = dict.get("CF");
|
||||
var streamCryptoName = dict.get("StmF");
|
||||
const cfDict = dict.get("CF");
|
||||
const streamCryptoName = dict.get("StmF");
|
||||
if (isDict(cfDict) && isName(streamCryptoName)) {
|
||||
cfDict.suppressEncryption = true; // See comment below.
|
||||
var handlerDict = cfDict.get(streamCryptoName.name);
|
||||
const handlerDict = cfDict.get(streamCryptoName.name);
|
||||
keyLength = (handlerDict && handlerDict.get("Length")) || 128;
|
||||
if (keyLength < 40) {
|
||||
// Sometimes it's incorrect value of bits, generators specify
|
||||
@ -1751,18 +1741,18 @@ var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
}
|
||||
|
||||
// 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");
|
||||
const ownerPassword = stringToBytes(dict.get("O")).subarray(0, 32);
|
||||
const userPassword = stringToBytes(dict.get("U")).subarray(0, 32);
|
||||
const flags = dict.get("P");
|
||||
const revision = dict.get("R");
|
||||
// meaningful when V is 4 or 5
|
||||
var encryptMetadata =
|
||||
const encryptMetadata =
|
||||
(algorithm === 4 || algorithm === 5) &&
|
||||
dict.get("EncryptMetadata") !== false;
|
||||
this.encryptMetadata = encryptMetadata;
|
||||
|
||||
var fileIdBytes = stringToBytes(fileId);
|
||||
var passwordBytes;
|
||||
const fileIdBytes = stringToBytes(fileId);
|
||||
let passwordBytes;
|
||||
if (password) {
|
||||
if (revision === 6) {
|
||||
try {
|
||||
@ -1777,7 +1767,7 @@ var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
passwordBytes = stringToBytes(password);
|
||||
}
|
||||
|
||||
var encryptionKey;
|
||||
let encryptionKey;
|
||||
if (algorithm !== 5) {
|
||||
encryptionKey = prepareKeyData(
|
||||
fileIdBytes,
|
||||
@ -1790,14 +1780,20 @@ var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
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"));
|
||||
const ownerValidationSalt = stringToBytes(dict.get("O")).subarray(
|
||||
32,
|
||||
40
|
||||
);
|
||||
const ownerKeySalt = stringToBytes(dict.get("O")).subarray(40, 48);
|
||||
const uBytes = stringToBytes(dict.get("U")).subarray(0, 48);
|
||||
const userValidationSalt = stringToBytes(dict.get("U")).subarray(
|
||||
32,
|
||||
40
|
||||
);
|
||||
const userKeySalt = stringToBytes(dict.get("U")).subarray(40, 48);
|
||||
const ownerEncryption = stringToBytes(dict.get("OE"));
|
||||
const userEncryption = stringToBytes(dict.get("UE"));
|
||||
const perms = stringToBytes(dict.get("Perms"));
|
||||
encryptionKey = createEncryptionKey20(
|
||||
revision,
|
||||
passwordBytes,
|
||||
@ -1820,7 +1816,7 @@ var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
);
|
||||
} else if (!encryptionKey && password) {
|
||||
// Attempting use the password as an owner password
|
||||
var decodedPassword = decodeUserPassword(
|
||||
const decodedPassword = decodeUserPassword(
|
||||
passwordBytes,
|
||||
ownerPassword,
|
||||
revision,
|
||||
@ -1848,7 +1844,7 @@ var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
this.encryptionKey = encryptionKey;
|
||||
|
||||
if (algorithm >= 4) {
|
||||
var cf = dict.get("CF");
|
||||
const cf = dict.get("CF");
|
||||
if (isDict(cf)) {
|
||||
// The 'CF' dictionary itself should not be encrypted, and by setting
|
||||
// `suppressEncryption` we can prevent an infinite loop inside of
|
||||
@ -1883,13 +1879,13 @@ var CipherTransformFactory = (function CipherTransformFactoryClosure() {
|
||||
);
|
||||
}
|
||||
// algorithms 1 and 2
|
||||
var key = buildObjectKey(
|
||||
const key = buildObjectKey(
|
||||
num,
|
||||
gen,
|
||||
this.encryptionKey,
|
||||
/* isAes = */ false
|
||||
);
|
||||
var cipherConstructor = function buildCipherCipherConstructor() {
|
||||
const cipherConstructor = function buildCipherCipherConstructor() {
|
||||
return new ARCFourCipher(key);
|
||||
};
|
||||
return new CipherTransform(cipherConstructor, cipherConstructor);
|
||||
|
||||
@ -12,7 +12,6 @@
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
/* eslint-disable no-var */
|
||||
|
||||
import { Dict, isDict, isStream, Ref } from "./primitives.js";
|
||||
import {
|
||||
@ -132,7 +131,7 @@ function toNumberArray(arr) {
|
||||
return arr;
|
||||
}
|
||||
|
||||
var PDFFunction = (function PDFFunctionClosure() {
|
||||
const PDFFunction = (function PDFFunctionClosure() {
|
||||
const CONSTRUCT_SAMPLED = 0;
|
||||
const CONSTRUCT_INTERPOLATED = 2;
|
||||
const CONSTRUCT_STICHED = 3;
|
||||
@ -140,21 +139,21 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
|
||||
return {
|
||||
getSampleArray(size, outputSize, bps, stream) {
|
||||
var i, ii;
|
||||
var length = 1;
|
||||
let i, ii;
|
||||
let length = 1;
|
||||
for (i = 0, ii = size.length; i < ii; i++) {
|
||||
length *= size[i];
|
||||
}
|
||||
length *= outputSize;
|
||||
|
||||
var array = new Array(length);
|
||||
var codeSize = 0;
|
||||
var codeBuf = 0;
|
||||
const array = new Array(length);
|
||||
let codeSize = 0;
|
||||
let codeBuf = 0;
|
||||
// 32 is a valid bps so shifting won't work
|
||||
var sampleMul = 1.0 / (2.0 ** bps - 1);
|
||||
const sampleMul = 1.0 / (2.0 ** bps - 1);
|
||||
|
||||
var strBytes = stream.getBytes((length * bps + 7) / 8);
|
||||
var strIdx = 0;
|
||||
const strBytes = stream.getBytes((length * bps + 7) / 8);
|
||||
let strIdx = 0;
|
||||
for (i = 0; i < length; i++) {
|
||||
while (codeSize < bps) {
|
||||
codeBuf <<= 8;
|
||||
@ -169,12 +168,12 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
},
|
||||
|
||||
getIR({ xref, isEvalSupported, fn }) {
|
||||
var dict = fn.dict;
|
||||
let dict = fn.dict;
|
||||
if (!dict) {
|
||||
dict = fn;
|
||||
}
|
||||
|
||||
var types = [
|
||||
const types = [
|
||||
this.constructSampled,
|
||||
null,
|
||||
this.constructInterpolated,
|
||||
@ -182,8 +181,8 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
this.constructPostScript,
|
||||
];
|
||||
|
||||
var typeNum = dict.get("FunctionType");
|
||||
var typeFn = types[typeNum];
|
||||
const typeNum = dict.get("FunctionType");
|
||||
const typeFn = types[typeNum];
|
||||
if (!typeFn) {
|
||||
throw new FormatError("Unknown type of function");
|
||||
}
|
||||
@ -192,7 +191,7 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
},
|
||||
|
||||
fromIR({ xref, isEvalSupported, IR }) {
|
||||
var type = IR[0];
|
||||
const type = IR[0];
|
||||
switch (type) {
|
||||
case CONSTRUCT_SAMPLED:
|
||||
return this.constructSampledFromIR({ xref, isEvalSupported, IR });
|
||||
@ -221,14 +220,14 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
return this.parse({ xref, isEvalSupported, fn: fnObj });
|
||||
}
|
||||
|
||||
var fnArray = [];
|
||||
for (var j = 0, jj = fnObj.length; j < jj; j++) {
|
||||
const fnArray = [];
|
||||
for (let j = 0, jj = fnObj.length; j < jj; j++) {
|
||||
fnArray.push(
|
||||
this.parse({ xref, isEvalSupported, fn: xref.fetchIfRef(fnObj[j]) })
|
||||
);
|
||||
}
|
||||
return function (src, srcOffset, dest, destOffset) {
|
||||
for (var i = 0, ii = fnArray.length; i < ii; i++) {
|
||||
for (let i = 0, ii = fnArray.length; i < ii; i++) {
|
||||
fnArray[i](src, srcOffset, dest, destOffset + i);
|
||||
}
|
||||
};
|
||||
@ -236,55 +235,55 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
|
||||
constructSampled({ xref, isEvalSupported, fn, dict }) {
|
||||
function toMultiArray(arr) {
|
||||
var inputLength = arr.length;
|
||||
var out = [];
|
||||
var index = 0;
|
||||
for (var i = 0; i < inputLength; i += 2) {
|
||||
const inputLength = arr.length;
|
||||
const out = [];
|
||||
let index = 0;
|
||||
for (let i = 0; i < inputLength; i += 2) {
|
||||
out[index] = [arr[i], arr[i + 1]];
|
||||
++index;
|
||||
}
|
||||
return out;
|
||||
}
|
||||
var domain = toNumberArray(dict.getArray("Domain"));
|
||||
var range = toNumberArray(dict.getArray("Range"));
|
||||
let domain = toNumberArray(dict.getArray("Domain"));
|
||||
let range = toNumberArray(dict.getArray("Range"));
|
||||
|
||||
if (!domain || !range) {
|
||||
throw new FormatError("No domain or range");
|
||||
}
|
||||
|
||||
var inputSize = domain.length / 2;
|
||||
var outputSize = range.length / 2;
|
||||
const inputSize = domain.length / 2;
|
||||
const outputSize = range.length / 2;
|
||||
|
||||
domain = toMultiArray(domain);
|
||||
range = toMultiArray(range);
|
||||
|
||||
var size = toNumberArray(dict.getArray("Size"));
|
||||
var bps = dict.get("BitsPerSample");
|
||||
var order = dict.get("Order") || 1;
|
||||
const size = toNumberArray(dict.getArray("Size"));
|
||||
const bps = dict.get("BitsPerSample");
|
||||
const order = dict.get("Order") || 1;
|
||||
if (order !== 1) {
|
||||
// No description how cubic spline interpolation works in PDF32000:2008
|
||||
// As in poppler, ignoring order, linear interpolation may work as good
|
||||
info("No support for cubic spline interpolation: " + order);
|
||||
}
|
||||
|
||||
var encode = toNumberArray(dict.getArray("Encode"));
|
||||
let encode = toNumberArray(dict.getArray("Encode"));
|
||||
if (!encode) {
|
||||
encode = [];
|
||||
for (var i = 0; i < inputSize; ++i) {
|
||||
for (let i = 0; i < inputSize; ++i) {
|
||||
encode.push([0, size[i] - 1]);
|
||||
}
|
||||
} else {
|
||||
encode = toMultiArray(encode);
|
||||
}
|
||||
|
||||
var decode = toNumberArray(dict.getArray("Decode"));
|
||||
let decode = toNumberArray(dict.getArray("Decode"));
|
||||
if (!decode) {
|
||||
decode = range;
|
||||
} else {
|
||||
decode = toMultiArray(decode);
|
||||
}
|
||||
|
||||
var samples = this.getSampleArray(size, outputSize, bps, fn);
|
||||
const samples = this.getSampleArray(size, outputSize, bps, fn);
|
||||
|
||||
return [
|
||||
CONSTRUCT_SAMPLED,
|
||||
@ -313,41 +312,41 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
destOffset
|
||||
) {
|
||||
// See chapter 3, page 110 of the PDF reference.
|
||||
var m = IR[1];
|
||||
var domain = IR[2];
|
||||
var encode = IR[3];
|
||||
var decode = IR[4];
|
||||
var samples = IR[5];
|
||||
var size = IR[6];
|
||||
var n = IR[7];
|
||||
const m = IR[1];
|
||||
const domain = IR[2];
|
||||
const encode = IR[3];
|
||||
const decode = IR[4];
|
||||
const samples = IR[5];
|
||||
const size = IR[6];
|
||||
const n = IR[7];
|
||||
// var mask = IR[8];
|
||||
var range = IR[9];
|
||||
const range = IR[9];
|
||||
|
||||
// Building the cube vertices: its part and sample index
|
||||
// http://rjwagner49.com/Mathematics/Interpolation.pdf
|
||||
var cubeVertices = 1 << m;
|
||||
var cubeN = new Float64Array(cubeVertices);
|
||||
var cubeVertex = new Uint32Array(cubeVertices);
|
||||
var i, j;
|
||||
const cubeVertices = 1 << m;
|
||||
const cubeN = new Float64Array(cubeVertices);
|
||||
const cubeVertex = new Uint32Array(cubeVertices);
|
||||
let i, j;
|
||||
for (j = 0; j < cubeVertices; j++) {
|
||||
cubeN[j] = 1;
|
||||
}
|
||||
|
||||
var k = n,
|
||||
let k = n,
|
||||
pos = 1;
|
||||
// Map x_i to y_j for 0 <= i < m using the sampled function.
|
||||
for (i = 0; i < m; ++i) {
|
||||
// x_i' = min(max(x_i, Domain_2i), Domain_2i+1)
|
||||
var domain_2i = domain[i][0];
|
||||
var domain_2i_1 = domain[i][1];
|
||||
var xi = Math.min(
|
||||
const domain_2i = domain[i][0];
|
||||
const domain_2i_1 = domain[i][1];
|
||||
const xi = Math.min(
|
||||
Math.max(src[srcOffset + i], domain_2i),
|
||||
domain_2i_1
|
||||
);
|
||||
|
||||
// e_i = Interpolate(x_i', Domain_2i, Domain_2i+1,
|
||||
// Encode_2i, Encode_2i+1)
|
||||
var e = interpolate(
|
||||
let e = interpolate(
|
||||
xi,
|
||||
domain_2i,
|
||||
domain_2i_1,
|
||||
@ -356,15 +355,15 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
);
|
||||
|
||||
// e_i' = min(max(e_i, 0), Size_i - 1)
|
||||
var size_i = size[i];
|
||||
const size_i = size[i];
|
||||
e = Math.min(Math.max(e, 0), size_i - 1);
|
||||
|
||||
// Adjusting the cube: N and vertex sample index
|
||||
var e0 = e < size_i - 1 ? Math.floor(e) : e - 1; // e1 = e0 + 1;
|
||||
var n0 = e0 + 1 - e; // (e1 - e) / (e1 - e0);
|
||||
var n1 = e - e0; // (e - e0) / (e1 - e0);
|
||||
var offset0 = e0 * k;
|
||||
var offset1 = offset0 + k; // e1 * k
|
||||
const e0 = e < size_i - 1 ? Math.floor(e) : e - 1; // e1 = e0 + 1;
|
||||
const n0 = e0 + 1 - e; // (e1 - e) / (e1 - e0);
|
||||
const n1 = e - e0; // (e - e0) / (e1 - e0);
|
||||
const offset0 = e0 * k;
|
||||
const offset1 = offset0 + k; // e1 * k
|
||||
for (j = 0; j < cubeVertices; j++) {
|
||||
if (j & pos) {
|
||||
cubeN[j] *= n1;
|
||||
@ -381,7 +380,7 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
|
||||
for (j = 0; j < n; ++j) {
|
||||
// Sum all cube vertices' samples portions
|
||||
var rj = 0;
|
||||
let rj = 0;
|
||||
for (i = 0; i < cubeVertices; i++) {
|
||||
rj += samples[cubeVertex[i] + j] * cubeN[i];
|
||||
}
|
||||
@ -400,13 +399,13 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
},
|
||||
|
||||
constructInterpolated({ xref, isEvalSupported, fn, dict }) {
|
||||
var c0 = toNumberArray(dict.getArray("C0")) || [0];
|
||||
var c1 = toNumberArray(dict.getArray("C1")) || [1];
|
||||
var n = dict.get("N");
|
||||
const c0 = toNumberArray(dict.getArray("C0")) || [0];
|
||||
const c1 = toNumberArray(dict.getArray("C1")) || [1];
|
||||
const n = dict.get("N");
|
||||
|
||||
var length = c0.length;
|
||||
var diff = [];
|
||||
for (var i = 0; i < length; ++i) {
|
||||
const length = c0.length;
|
||||
const diff = [];
|
||||
for (let i = 0; i < length; ++i) {
|
||||
diff.push(c1[i] - c0[i]);
|
||||
}
|
||||
|
||||
@ -414,11 +413,11 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
},
|
||||
|
||||
constructInterpolatedFromIR({ xref, isEvalSupported, IR }) {
|
||||
var c0 = IR[1];
|
||||
var diff = IR[2];
|
||||
var n = IR[3];
|
||||
const c0 = IR[1];
|
||||
const diff = IR[2];
|
||||
const n = IR[3];
|
||||
|
||||
var length = diff.length;
|
||||
const length = diff.length;
|
||||
|
||||
return function constructInterpolatedFromIRResult(
|
||||
src,
|
||||
@ -426,46 +425,46 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
dest,
|
||||
destOffset
|
||||
) {
|
||||
var x = n === 1 ? src[srcOffset] : src[srcOffset] ** n;
|
||||
const x = n === 1 ? src[srcOffset] : src[srcOffset] ** n;
|
||||
|
||||
for (var j = 0; j < length; ++j) {
|
||||
for (let j = 0; j < length; ++j) {
|
||||
dest[destOffset + j] = c0[j] + x * diff[j];
|
||||
}
|
||||
};
|
||||
},
|
||||
|
||||
constructStiched({ xref, isEvalSupported, fn, dict }) {
|
||||
var domain = toNumberArray(dict.getArray("Domain"));
|
||||
const domain = toNumberArray(dict.getArray("Domain"));
|
||||
|
||||
if (!domain) {
|
||||
throw new FormatError("No domain");
|
||||
}
|
||||
|
||||
var inputSize = domain.length / 2;
|
||||
const inputSize = domain.length / 2;
|
||||
if (inputSize !== 1) {
|
||||
throw new FormatError("Bad domain for stiched function");
|
||||
}
|
||||
|
||||
var fnRefs = dict.get("Functions");
|
||||
var fns = [];
|
||||
for (var i = 0, ii = fnRefs.length; i < ii; ++i) {
|
||||
const fnRefs = dict.get("Functions");
|
||||
const fns = [];
|
||||
for (let i = 0, ii = fnRefs.length; i < ii; ++i) {
|
||||
fns.push(
|
||||
this.parse({ xref, isEvalSupported, fn: xref.fetchIfRef(fnRefs[i]) })
|
||||
);
|
||||
}
|
||||
|
||||
var bounds = toNumberArray(dict.getArray("Bounds"));
|
||||
var encode = toNumberArray(dict.getArray("Encode"));
|
||||
const bounds = toNumberArray(dict.getArray("Bounds"));
|
||||
const encode = toNumberArray(dict.getArray("Encode"));
|
||||
|
||||
return [CONSTRUCT_STICHED, domain, bounds, encode, fns];
|
||||
},
|
||||
|
||||
constructStichedFromIR({ xref, isEvalSupported, IR }) {
|
||||
var domain = IR[1];
|
||||
var bounds = IR[2];
|
||||
var encode = IR[3];
|
||||
var fns = IR[4];
|
||||
var tmpBuf = new Float32Array(1);
|
||||
const domain = IR[1];
|
||||
const bounds = IR[2];
|
||||
const encode = IR[3];
|
||||
const fns = IR[4];
|
||||
const tmpBuf = new Float32Array(1);
|
||||
|
||||
return function constructStichedFromIRResult(
|
||||
src,
|
||||
@ -473,7 +472,7 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
dest,
|
||||
destOffset
|
||||
) {
|
||||
var clip = function constructStichedFromIRClip(v, min, max) {
|
||||
const clip = function constructStichedFromIRClip(v, min, max) {
|
||||
if (v > max) {
|
||||
v = max;
|
||||
} else if (v < min) {
|
||||
@ -483,26 +482,28 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
};
|
||||
|
||||
// clip to domain
|
||||
var v = clip(src[srcOffset], domain[0], domain[1]);
|
||||
const v = clip(src[srcOffset], domain[0], domain[1]);
|
||||
// calculate which bound the value is in
|
||||
for (var i = 0, ii = bounds.length; i < ii; ++i) {
|
||||
const length = bounds.length;
|
||||
let i;
|
||||
for (i = 0; i < length; ++i) {
|
||||
if (v < bounds[i]) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// encode value into domain of function
|
||||
var dmin = domain[0];
|
||||
let dmin = domain[0];
|
||||
if (i > 0) {
|
||||
dmin = bounds[i - 1];
|
||||
}
|
||||
var dmax = domain[1];
|
||||
let dmax = domain[1];
|
||||
if (i < bounds.length) {
|
||||
dmax = bounds[i];
|
||||
}
|
||||
|
||||
var rmin = encode[2 * i];
|
||||
var rmax = encode[2 * i + 1];
|
||||
const rmin = encode[2 * i];
|
||||
const rmax = encode[2 * i + 1];
|
||||
|
||||
// Prevent the value from becoming NaN as a result
|
||||
// of division by zero (fixes issue6113.pdf).
|
||||
@ -517,8 +518,8 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
},
|
||||
|
||||
constructPostScript({ xref, isEvalSupported, fn, dict }) {
|
||||
var domain = toNumberArray(dict.getArray("Domain"));
|
||||
var range = toNumberArray(dict.getArray("Range"));
|
||||
const domain = toNumberArray(dict.getArray("Domain"));
|
||||
const range = toNumberArray(dict.getArray("Range"));
|
||||
|
||||
if (!domain) {
|
||||
throw new FormatError("No domain.");
|
||||
@ -528,17 +529,17 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
throw new FormatError("No range.");
|
||||
}
|
||||
|
||||
var lexer = new PostScriptLexer(fn);
|
||||
var parser = new PostScriptParser(lexer);
|
||||
var code = parser.parse();
|
||||
const lexer = new PostScriptLexer(fn);
|
||||
const parser = new PostScriptParser(lexer);
|
||||
const code = parser.parse();
|
||||
|
||||
return [CONSTRUCT_POSTSCRIPT, domain, range, code];
|
||||
},
|
||||
|
||||
constructPostScriptFromIR({ xref, isEvalSupported, IR }) {
|
||||
var domain = IR[1];
|
||||
var range = IR[2];
|
||||
var code = IR[3];
|
||||
const domain = IR[1];
|
||||
const range = IR[2];
|
||||
const code = IR[3];
|
||||
|
||||
if (isEvalSupported && IsEvalSupportedCached.value) {
|
||||
const compiled = new PostScriptCompiler().compile(code, domain, range);
|
||||
@ -558,17 +559,17 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
}
|
||||
info("Unable to compile PS function");
|
||||
|
||||
var numOutputs = range.length >> 1;
|
||||
var numInputs = domain.length >> 1;
|
||||
var evaluator = new PostScriptEvaluator(code);
|
||||
const numOutputs = range.length >> 1;
|
||||
const numInputs = domain.length >> 1;
|
||||
const evaluator = new PostScriptEvaluator(code);
|
||||
// Cache the values for a big speed up, the cache size is limited though
|
||||
// since the number of possible values can be huge from a PS function.
|
||||
var cache = Object.create(null);
|
||||
const cache = Object.create(null);
|
||||
// The MAX_CACHE_SIZE is set to ~4x the maximum number of distinct values
|
||||
// seen in our tests.
|
||||
var MAX_CACHE_SIZE = 2048 * 4;
|
||||
var cache_available = MAX_CACHE_SIZE;
|
||||
var tmpBuf = new Float32Array(numInputs);
|
||||
const MAX_CACHE_SIZE = 2048 * 4;
|
||||
let cache_available = MAX_CACHE_SIZE;
|
||||
const tmpBuf = new Float32Array(numInputs);
|
||||
|
||||
return function constructPostScriptFromIRResult(
|
||||
src,
|
||||
@ -576,27 +577,27 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
dest,
|
||||
destOffset
|
||||
) {
|
||||
var i, value;
|
||||
var key = "";
|
||||
var input = tmpBuf;
|
||||
let i, value;
|
||||
let key = "";
|
||||
const input = tmpBuf;
|
||||
for (i = 0; i < numInputs; i++) {
|
||||
value = src[srcOffset + i];
|
||||
input[i] = value;
|
||||
key += value + "_";
|
||||
}
|
||||
|
||||
var cachedValue = cache[key];
|
||||
const cachedValue = cache[key];
|
||||
if (cachedValue !== undefined) {
|
||||
dest.set(cachedValue, destOffset);
|
||||
return;
|
||||
}
|
||||
|
||||
var output = new Float32Array(numOutputs);
|
||||
var stack = evaluator.execute(input);
|
||||
var stackIndex = stack.length - numOutputs;
|
||||
const output = new Float32Array(numOutputs);
|
||||
const stack = evaluator.execute(input);
|
||||
const stackIndex = stack.length - numOutputs;
|
||||
for (i = 0; i < numOutputs; i++) {
|
||||
value = stack[stackIndex + i];
|
||||
var bound = range[i * 2];
|
||||
let bound = range[i * 2];
|
||||
if (value < bound) {
|
||||
value = bound;
|
||||
} else {
|
||||
@ -618,7 +619,7 @@ var PDFFunction = (function PDFFunctionClosure() {
|
||||
})();
|
||||
|
||||
function isPDFFunction(v) {
|
||||
var fnDict;
|
||||
let fnDict;
|
||||
if (typeof v !== "object") {
|
||||
return false;
|
||||
} else if (isDict(v)) {
|
||||
@ -631,8 +632,8 @@ function isPDFFunction(v) {
|
||||
return fnDict.has("FunctionType");
|
||||
}
|
||||
|
||||
var PostScriptStack = (function PostScriptStackClosure() {
|
||||
var MAX_STACK_SIZE = 100;
|
||||
const PostScriptStack = (function PostScriptStackClosure() {
|
||||
const MAX_STACK_SIZE = 100;
|
||||
|
||||
// eslint-disable-next-line no-shadow
|
||||
class PostScriptStack {
|
||||
@ -660,8 +661,8 @@ var PostScriptStack = (function PostScriptStackClosure() {
|
||||
if (this.stack.length + n >= MAX_STACK_SIZE) {
|
||||
throw new Error("PostScript function stack overflow.");
|
||||
}
|
||||
var stack = this.stack;
|
||||
for (var i = stack.length - n, j = n - 1; j >= 0; j--, i++) {
|
||||
const stack = this.stack;
|
||||
for (let i = stack.length - n, j = n - 1; j >= 0; j--, i++) {
|
||||
stack.push(stack[i]);
|
||||
}
|
||||
}
|
||||
@ -672,25 +673,23 @@ var PostScriptStack = (function PostScriptStackClosure() {
|
||||
|
||||
// rotate the last n stack elements p times
|
||||
roll(n, p) {
|
||||
var stack = this.stack;
|
||||
var l = stack.length - n;
|
||||
var r = stack.length - 1,
|
||||
c = l + (p - Math.floor(p / n) * n),
|
||||
i,
|
||||
j,
|
||||
t;
|
||||
for (i = l, j = r; i < j; i++, j--) {
|
||||
t = stack[i];
|
||||
const stack = this.stack;
|
||||
const l = stack.length - n;
|
||||
const r = stack.length - 1;
|
||||
const c = l + (p - Math.floor(p / n) * n);
|
||||
|
||||
for (let i = l, j = r; i < j; i++, j--) {
|
||||
const t = stack[i];
|
||||
stack[i] = stack[j];
|
||||
stack[j] = t;
|
||||
}
|
||||
for (i = l, j = c - 1; i < j; i++, j--) {
|
||||
t = stack[i];
|
||||
for (let i = l, j = c - 1; i < j; i++, j--) {
|
||||
const t = stack[i];
|
||||
stack[i] = stack[j];
|
||||
stack[j] = t;
|
||||
}
|
||||
for (i = c, j = r; i < j; i++, j--) {
|
||||
t = stack[i];
|
||||
for (let i = c, j = r; i < j; i++, j--) {
|
||||
const t = stack[i];
|
||||
stack[i] = stack[j];
|
||||
stack[j] = t;
|
||||
}
|
||||
@ -706,11 +705,11 @@ class PostScriptEvaluator {
|
||||
}
|
||||
|
||||
execute(initialStack) {
|
||||
var stack = new PostScriptStack(initialStack);
|
||||
var counter = 0;
|
||||
var operators = this.operators;
|
||||
var length = operators.length;
|
||||
var operator, a, b;
|
||||
const stack = new PostScriptStack(initialStack);
|
||||
let counter = 0;
|
||||
const operators = this.operators;
|
||||
const length = operators.length;
|
||||
let operator, a, b;
|
||||
while (counter < length) {
|
||||
operator = operators[counter++];
|
||||
if (typeof operator === "number") {
|
||||
@ -940,7 +939,7 @@ class PostScriptEvaluator {
|
||||
// We can compile most of such programs, and at the same moment, we can
|
||||
// optimize some expressions using basic math properties. Keeping track of
|
||||
// min/max values will allow us to avoid extra Math.min/Math.max calls.
|
||||
var PostScriptCompiler = (function PostScriptCompilerClosure() {
|
||||
const PostScriptCompiler = (function PostScriptCompilerClosure() {
|
||||
class AstNode {
|
||||
constructor(type) {
|
||||
this.type = type;
|
||||
@ -1124,13 +1123,13 @@ var PostScriptCompiler = (function PostScriptCompilerClosure() {
|
||||
return num2; // and it's 1
|
||||
}
|
||||
}
|
||||
var min = Math.min(
|
||||
const min = Math.min(
|
||||
num1.min * num2.min,
|
||||
num1.min * num2.max,
|
||||
num1.max * num2.min,
|
||||
num1.max * num2.max
|
||||
);
|
||||
var max = Math.max(
|
||||
const max = Math.max(
|
||||
num1.min * num2.min,
|
||||
num1.min * num2.max,
|
||||
num1.max * num2.min,
|
||||
@ -1183,13 +1182,13 @@ var PostScriptCompiler = (function PostScriptCompilerClosure() {
|
||||
// eslint-disable-next-line no-shadow
|
||||
class PostScriptCompiler {
|
||||
compile(code, domain, range) {
|
||||
var stack = [];
|
||||
var instructions = [];
|
||||
var inputSize = domain.length >> 1,
|
||||
const stack = [];
|
||||
const instructions = [];
|
||||
const inputSize = domain.length >> 1,
|
||||
outputSize = range.length >> 1;
|
||||
var lastRegister = 0;
|
||||
var n, j;
|
||||
var num1, num2, ast1, ast2, tmpVar, item;
|
||||
let lastRegister = 0;
|
||||
let n, j;
|
||||
let num1, num2, ast1, ast2, tmpVar, item;
|
||||
for (let i = 0; i < inputSize; i++) {
|
||||
stack.push(new AstArgument(i, domain[i * 2], domain[i * 2 + 1]));
|
||||
}
|
||||
@ -1336,7 +1335,7 @@ var PostScriptCompiler = (function PostScriptCompilerClosure() {
|
||||
return null;
|
||||
}
|
||||
|
||||
var result = [];
|
||||
const result = [];
|
||||
for (const instruction of instructions) {
|
||||
const statementBuilder = new ExpressionBuilderVisitor();
|
||||
instruction.visit(statementBuilder);
|
||||
@ -1346,9 +1345,9 @@ var PostScriptCompiler = (function PostScriptCompilerClosure() {
|
||||
const expr = stack[i],
|
||||
statementBuilder = new ExpressionBuilderVisitor();
|
||||
expr.visit(statementBuilder);
|
||||
var min = range[i * 2],
|
||||
const min = range[i * 2],
|
||||
max = range[i * 2 + 1];
|
||||
var out = [statementBuilder.toString()];
|
||||
const out = [statementBuilder.toString()];
|
||||
if (min > expr.min) {
|
||||
out.unshift("Math.max(", min, ", ");
|
||||
out.push(")");
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user