pdfjs-dist 2.6.347 → 2.7.570

package/lib/test/unit/function_spec.js

@@ -33,7 +33,7 @@ describe("function", function () {
       toMatchArray(util, customEqualityTesters) {
         return {
           compare(actual, expected) {
-            var result = {};
+            const result = {};
 
             if (actual.length !== expected.length) {
               result.pass = false;
@@ -43,9 +43,9 @@ describe("function", function () {
 
             result.pass = true;
 
-            for (var i = 0; i < expected.length; i++) {
-              var a = actual[i],
-                  b = expected[i];
+            for (let i = 0; i < expected.length; i++) {
+              const a = actual[i],
+                    b = expected[i];
 
               if (Array.isArray(b)) {
                 if (a.length !== b.length) {
@@ -53,9 +53,9 @@ describe("function", function () {
                   break;
                 }
 
-                for (var j = 0; j < a.length; j++) {
-                  var suba = a[j],
-                      subb = b[j];
+                for (let j = 0; j < a.length; j++) {
+                  const suba = a[j],
+                        subb = b[j];
 
                   if (suba !== subb) {
                     result.pass = false;
@@ -80,46 +80,46 @@ describe("function", function () {
   });
   describe("PostScriptParser", function () {
     function parse(program) {
-      var stream = new _stream.StringStream(program);
-      var parser = new _ps_parser.PostScriptParser(new _ps_parser.PostScriptLexer(stream));
+      const stream = new _stream.StringStream(program);
+      const parser = new _ps_parser.PostScriptParser(new _ps_parser.PostScriptLexer(stream));
       return parser.parse();
     }
 
     it("parses empty programs", function () {
-      var output = parse("{}");
+      const output = parse("{}");
       expect(output.length).toEqual(0);
     });
     it("parses positive numbers", function () {
-      var number = 999;
-      var program = parse("{ " + number + " }");
-      var expectedProgram = [number];
+      const number = 999;
+      const program = parse("{ " + number + " }");
+      const expectedProgram = [number];
       expect(program).toMatchArray(expectedProgram);
     });
     it("parses negative numbers", function () {
-      var number = -999;
-      var program = parse("{ " + number + " }");
-      var expectedProgram = [number];
+      const number = -999;
+      const program = parse("{ " + number + " }");
+      const expectedProgram = [number];
       expect(program).toMatchArray(expectedProgram);
     });
     it("parses negative floats", function () {
-      var number = 3.3;
-      var program = parse("{ " + number + " }");
-      var expectedProgram = [number];
+      const number = 3.3;
+      const program = parse("{ " + number + " }");
+      const expectedProgram = [number];
       expect(program).toMatchArray(expectedProgram);
     });
     it("parses operators", function () {
-      var program = parse("{ sub }");
-      var expectedProgram = ["sub"];
+      const program = parse("{ sub }");
+      const expectedProgram = ["sub"];
       expect(program).toMatchArray(expectedProgram);
     });
     it("parses if statements", function () {
-      var program = parse("{ { 99 } if }");
-      var expectedProgram = [3, "jz", 99];
+      const program = parse("{ { 99 } if }");
+      const expectedProgram = [3, "jz", 99];
       expect(program).toMatchArray(expectedProgram);
     });
     it("parses ifelse statements", function () {
-      var program = parse("{ { 99 } { 44 } ifelse }");
-      var expectedProgram = [5, "jz", 99, 6, "j", 44];
+      const program = parse("{ { 99 } { 44 } ifelse }");
+      const expectedProgram = [5, "jz", 99, 6, "j", 44];
       expect(program).toMatchArray(expectedProgram);
     });
     it("handles missing brackets", function () {
@@ -128,346 +128,346 @@ describe("function", function () {
       }).toThrow(new Error("Unexpected symbol: found undefined expected 1."));
     });
     it("handles junk after the end", function () {
-      var number = 3.3;
-      var program = parse("{ " + number + " }#");
-      var expectedProgram = [number];
+      const number = 3.3;
+      const program = parse("{ " + number + " }#");
+      const expectedProgram = [number];
       expect(program).toMatchArray(expectedProgram);
     });
   });
   describe("PostScriptEvaluator", function () {
     function evaluate(program) {
-      var stream = new _stream.StringStream(program);
-      var parser = new _ps_parser.PostScriptParser(new _ps_parser.PostScriptLexer(stream));
-      var code = parser.parse();
-      var evaluator = new _function.PostScriptEvaluator(code);
-      var output = evaluator.execute();
+      const stream = new _stream.StringStream(program);
+      const parser = new _ps_parser.PostScriptParser(new _ps_parser.PostScriptLexer(stream));
+      const code = parser.parse();
+      const evaluator = new _function.PostScriptEvaluator(code);
+      const output = evaluator.execute();
       return output;
     }
 
     it("pushes stack", function () {
-      var stack = evaluate("{ 99 }");
-      var expectedStack = [99];
+      const stack = evaluate("{ 99 }");
+      const expectedStack = [99];
       expect(stack).toMatchArray(expectedStack);
     });
     it("handles if with true", function () {
-      var stack = evaluate("{ 1 {99} if }");
-      var expectedStack = [99];
+      const stack = evaluate("{ 1 {99} if }");
+      const expectedStack = [99];
       expect(stack).toMatchArray(expectedStack);
     });
     it("handles if with false", function () {
-      var stack = evaluate("{ 0 {99} if }");
-      var expectedStack = [];
+      const stack = evaluate("{ 0 {99} if }");
+      const expectedStack = [];
       expect(stack).toMatchArray(expectedStack);
     });
     it("handles ifelse with true", function () {
-      var stack = evaluate("{ 1 {99} {77} ifelse }");
-      var expectedStack = [99];
+      const stack = evaluate("{ 1 {99} {77} ifelse }");
+      const expectedStack = [99];
       expect(stack).toMatchArray(expectedStack);
     });
     it("handles ifelse with false", function () {
-      var stack = evaluate("{ 0 {99} {77} ifelse }");
-      var expectedStack = [77];
+      const stack = evaluate("{ 0 {99} {77} ifelse }");
+      const expectedStack = [77];
       expect(stack).toMatchArray(expectedStack);
     });
     it("handles nested if", function () {
-      var stack = evaluate("{ 1 {1 {77} if} if }");
-      var expectedStack = [77];
+      const stack = evaluate("{ 1 {1 {77} if} if }");
+      const expectedStack = [77];
       expect(stack).toMatchArray(expectedStack);
     });
     it("abs", function () {
-      var stack = evaluate("{ -2 abs }");
-      var expectedStack = [2];
+      const stack = evaluate("{ -2 abs }");
+      const expectedStack = [2];
       expect(stack).toMatchArray(expectedStack);
     });
     it("adds", function () {
-      var stack = evaluate("{ 1 2 add }");
-      var expectedStack = [3];
+      const stack = evaluate("{ 1 2 add }");
+      const expectedStack = [3];
       expect(stack).toMatchArray(expectedStack);
     });
     it("boolean and", function () {
-      var stack = evaluate("{ true false and }");
-      var expectedStack = [false];
+      const stack = evaluate("{ true false and }");
+      const expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
     it("bitwise and", function () {
-      var stack = evaluate("{ 254 1 and }");
-      var expectedStack = [254 & 1];
+      const stack = evaluate("{ 254 1 and }");
+      const expectedStack = [254 & 1];
       expect(stack).toMatchArray(expectedStack);
     });
     it("calculates the inverse tangent of a number", function () {
-      var stack = evaluate("{ 90 atan }");
-      var expectedStack = [Math.atan(90)];
+      const stack = evaluate("{ 90 atan }");
+      const expectedStack = [Math.atan(90)];
       expect(stack).toMatchArray(expectedStack);
     });
     it("handles bitshifting ", function () {
-      var stack = evaluate("{ 50 2 bitshift }");
-      var expectedStack = [200];
+      const stack = evaluate("{ 50 2 bitshift }");
+      const expectedStack = [200];
       expect(stack).toMatchArray(expectedStack);
     });
     it("calculates the ceiling value", function () {
-      var stack = evaluate("{ 9.9 ceiling }");
-      var expectedStack = [10];
+      const stack = evaluate("{ 9.9 ceiling }");
+      const expectedStack = [10];
       expect(stack).toMatchArray(expectedStack);
     });
     it("copies", function () {
-      var stack = evaluate("{ 99 98 2 copy }");
-      var expectedStack = [99, 98, 99, 98];
+      const stack = evaluate("{ 99 98 2 copy }");
+      const expectedStack = [99, 98, 99, 98];
       expect(stack).toMatchArray(expectedStack);
     });
     it("calculates the cosine of a number", function () {
-      var stack = evaluate("{ 90 cos }");
-      var expectedStack = [Math.cos(90)];
+      const stack = evaluate("{ 90 cos }");
+      const expectedStack = [Math.cos(90)];
       expect(stack).toMatchArray(expectedStack);
     });
     it("converts to int", function () {
-      var stack = evaluate("{ 9.9 cvi }");
-      var expectedStack = [9];
+      const stack = evaluate("{ 9.9 cvi }");
+      const expectedStack = [9];
       expect(stack).toMatchArray(expectedStack);
     });
     it("converts negatives to int", function () {
-      var stack = evaluate("{ -9.9 cvi }");
-      var expectedStack = [-9];
+      const stack = evaluate("{ -9.9 cvi }");
+      const expectedStack = [-9];
       expect(stack).toMatchArray(expectedStack);
     });
     it("converts to real", function () {
-      var stack = evaluate("{ 55.34 cvr }");
-      var expectedStack = [55.34];
+      const stack = evaluate("{ 55.34 cvr }");
+      const expectedStack = [55.34];
       expect(stack).toMatchArray(expectedStack);
     });
     it("divides", function () {
-      var stack = evaluate("{ 6 5 div }");
-      var expectedStack = [1.2];
+      const stack = evaluate("{ 6 5 div }");
+      const expectedStack = [1.2];
       expect(stack).toMatchArray(expectedStack);
     });
     it("maps division by zero to infinity", function () {
-      var stack = evaluate("{ 6 0 div }");
-      var expectedStack = [Infinity];
+      const stack = evaluate("{ 6 0 div }");
+      const expectedStack = [Infinity];
       expect(stack).toMatchArray(expectedStack);
     });
     it("duplicates", function () {
-      var stack = evaluate("{ 99 dup }");
-      var expectedStack = [99, 99];
+      const stack = evaluate("{ 99 dup }");
+      const expectedStack = [99, 99];
       expect(stack).toMatchArray(expectedStack);
     });
     it("accepts an equality", function () {
-      var stack = evaluate("{ 9 9 eq }");
-      var expectedStack = [true];
+      const stack = evaluate("{ 9 9 eq }");
+      const expectedStack = [true];
       expect(stack).toMatchArray(expectedStack);
     });
     it("rejects an inequality", function () {
-      var stack = evaluate("{ 9 8 eq }");
-      var expectedStack = [false];
+      const stack = evaluate("{ 9 8 eq }");
+      const expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
     it("exchanges", function () {
-      var stack = evaluate("{ 44 99 exch }");
-      var expectedStack = [99, 44];
+      const stack = evaluate("{ 44 99 exch }");
+      const expectedStack = [99, 44];
       expect(stack).toMatchArray(expectedStack);
     });
     it("handles exponentiation", function () {
-      var stack = evaluate("{ 10 2 exp }");
-      var expectedStack = [100];
+      const stack = evaluate("{ 10 2 exp }");
+      const expectedStack = [100];
       expect(stack).toMatchArray(expectedStack);
     });
     it("pushes false onto the stack", function () {
-      var stack = evaluate("{ false }");
-      var expectedStack = [false];
+      const stack = evaluate("{ false }");
+      const expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
     it("calculates the floor value", function () {
-      var stack = evaluate("{ 9.9 floor }");
-      var expectedStack = [9];
+      const stack = evaluate("{ 9.9 floor }");
+      const expectedStack = [9];
       expect(stack).toMatchArray(expectedStack);
     });
     it("handles greater than or equal to", function () {
-      var stack = evaluate("{ 10 9 ge }");
-      var expectedStack = [true];
+      const stack = evaluate("{ 10 9 ge }");
+      const expectedStack = [true];
       expect(stack).toMatchArray(expectedStack);
     });
     it("rejects less than for greater than or equal to", function () {
-      var stack = evaluate("{ 8 9 ge }");
-      var expectedStack = [false];
+      const stack = evaluate("{ 8 9 ge }");
+      const expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
     it("handles greater than", function () {
-      var stack = evaluate("{ 10 9 gt }");
-      var expectedStack = [true];
+      const stack = evaluate("{ 10 9 gt }");
+      const expectedStack = [true];
       expect(stack).toMatchArray(expectedStack);
     });
     it("rejects less than or equal for greater than", function () {
-      var stack = evaluate("{ 9 9 gt }");
-      var expectedStack = [false];
+      const stack = evaluate("{ 9 9 gt }");
+      const expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
     it("divides to integer", function () {
-      var stack = evaluate("{ 2 3 idiv }");
-      var expectedStack = [0];
+      const stack = evaluate("{ 2 3 idiv }");
+      const expectedStack = [0];
       expect(stack).toMatchArray(expectedStack);
     });
     it("divides to negative integer", function () {
-      var stack = evaluate("{ -2 3 idiv }");
-      var expectedStack = [0];
+      const stack = evaluate("{ -2 3 idiv }");
+      const expectedStack = [0];
       expect(stack).toMatchArray(expectedStack);
     });
     it("duplicates index", function () {
-      var stack = evaluate("{ 4 3 2 1 2 index }");
-      var expectedStack = [4, 3, 2, 1, 3];
+      const stack = evaluate("{ 4 3 2 1 2 index }");
+      const expectedStack = [4, 3, 2, 1, 3];
       expect(stack).toMatchArray(expectedStack);
     });
     it("handles less than or equal to", function () {
-      var stack = evaluate("{ 9 10 le }");
-      var expectedStack = [true];
+      const stack = evaluate("{ 9 10 le }");
+      const expectedStack = [true];
       expect(stack).toMatchArray(expectedStack);
     });
     it("rejects greater than for less than or equal to", function () {
-      var stack = evaluate("{ 10 9 le }");
-      var expectedStack = [false];
+      const stack = evaluate("{ 10 9 le }");
+      const expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
     it("calculates the natural logarithm", function () {
-      var stack = evaluate("{ 10 ln }");
-      var expectedStack = [Math.log(10)];
+      const stack = evaluate("{ 10 ln }");
+      const expectedStack = [Math.log(10)];
       expect(stack).toMatchArray(expectedStack);
     });
     it("calculates the base 10 logarithm", function () {
-      var stack = evaluate("{ 100 log }");
-      var expectedStack = [2];
+      const stack = evaluate("{ 100 log }");
+      const expectedStack = [2];
       expect(stack).toMatchArray(expectedStack);
     });
     it("handles less than", function () {
-      var stack = evaluate("{ 9 10 lt }");
-      var expectedStack = [true];
+      const stack = evaluate("{ 9 10 lt }");
+      const expectedStack = [true];
       expect(stack).toMatchArray(expectedStack);
     });
     it("rejects greater than or equal to for less than", function () {
-      var stack = evaluate("{ 10 9 lt }");
-      var expectedStack = [false];
+      const stack = evaluate("{ 10 9 lt }");
+      const expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
     it("performs the modulo operation", function () {
-      var stack = evaluate("{ 4 3 mod }");
-      var expectedStack = [1];
+      const stack = evaluate("{ 4 3 mod }");
+      const expectedStack = [1];
       expect(stack).toMatchArray(expectedStack);
     });
     it("multiplies two numbers (positive result)", function () {
-      var stack = evaluate("{ 9 8 mul }");
-      var expectedStack = [72];
+      const stack = evaluate("{ 9 8 mul }");
+      const expectedStack = [72];
       expect(stack).toMatchArray(expectedStack);
     });
     it("multiplies two numbers (negative result)", function () {
-      var stack = evaluate("{ 9 -8 mul }");
-      var expectedStack = [-72];
+      const stack = evaluate("{ 9 -8 mul }");
+      const expectedStack = [-72];
       expect(stack).toMatchArray(expectedStack);
     });
     it("accepts an inequality", function () {
-      var stack = evaluate("{ 9 8 ne }");
-      var expectedStack = [true];
+      const stack = evaluate("{ 9 8 ne }");
+      const expectedStack = [true];
       expect(stack).toMatchArray(expectedStack);
     });
     it("rejects an equality", function () {
-      var stack = evaluate("{ 9 9 ne }");
-      var expectedStack = [false];
+      const stack = evaluate("{ 9 9 ne }");
+      const expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
     it("negates", function () {
-      var stack = evaluate("{ 4.5 neg }");
-      var expectedStack = [-4.5];
+      const stack = evaluate("{ 4.5 neg }");
+      const expectedStack = [-4.5];
       expect(stack).toMatchArray(expectedStack);
     });
     it("boolean not", function () {
-      var stack = evaluate("{ true not }");
-      var expectedStack = [false];
+      const stack = evaluate("{ true not }");
+      const expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
     it("bitwise not", function () {
-      var stack = evaluate("{ 12 not }");
-      var expectedStack = [-13];
+      const stack = evaluate("{ 12 not }");
+      const expectedStack = [-13];
       expect(stack).toMatchArray(expectedStack);
     });
     it("boolean or", function () {
-      var stack = evaluate("{ true false or }");
-      var expectedStack = [true];
+      const stack = evaluate("{ true false or }");
+      const expectedStack = [true];
       expect(stack).toMatchArray(expectedStack);
     });
     it("bitwise or", function () {
-      var stack = evaluate("{ 254 1 or }");
-      var expectedStack = [254 | 1];
+      const stack = evaluate("{ 254 1 or }");
+      const expectedStack = [254 | 1];
       expect(stack).toMatchArray(expectedStack);
     });
     it("pops stack", function () {
-      var stack = evaluate("{ 1 2 pop }");
-      var expectedStack = [1];
+      const stack = evaluate("{ 1 2 pop }");
+      const expectedStack = [1];
       expect(stack).toMatchArray(expectedStack);
     });
     it("rolls stack right", function () {
-      var stack = evaluate("{ 1 3 2 2 4 1 roll }");
-      var expectedStack = [2, 1, 3, 2];
+      const stack = evaluate("{ 1 3 2 2 4 1 roll }");
+      const expectedStack = [2, 1, 3, 2];
       expect(stack).toMatchArray(expectedStack);
     });
     it("rolls stack left", function () {
-      var stack = evaluate("{ 1 3 2 2 4 -1 roll }");
-      var expectedStack = [3, 2, 2, 1];
+      const stack = evaluate("{ 1 3 2 2 4 -1 roll }");
+      const expectedStack = [3, 2, 2, 1];
       expect(stack).toMatchArray(expectedStack);
     });
     it("rounds a number", function () {
-      var stack = evaluate("{ 9.52 round }");
-      var expectedStack = [10];
+      const stack = evaluate("{ 9.52 round }");
+      const expectedStack = [10];
       expect(stack).toMatchArray(expectedStack);
     });
     it("calculates the sine of a number", function () {
-      var stack = evaluate("{ 90 sin }");
-      var expectedStack = [Math.sin(90)];
+      const stack = evaluate("{ 90 sin }");
+      const expectedStack = [Math.sin(90)];
       expect(stack).toMatchArray(expectedStack);
     });
     it("calculates a square root (integer)", function () {
-      var stack = evaluate("{ 100 sqrt }");
-      var expectedStack = [10];
+      const stack = evaluate("{ 100 sqrt }");
+      const expectedStack = [10];
       expect(stack).toMatchArray(expectedStack);
     });
     it("calculates a square root (float)", function () {
-      var stack = evaluate("{ 99 sqrt }");
-      var expectedStack = [Math.sqrt(99)];
+      const stack = evaluate("{ 99 sqrt }");
+      const expectedStack = [Math.sqrt(99)];
       expect(stack).toMatchArray(expectedStack);
     });
     it("subtracts (positive result)", function () {
-      var stack = evaluate("{ 6 4 sub }");
-      var expectedStack = [2];
+      const stack = evaluate("{ 6 4 sub }");
+      const expectedStack = [2];
       expect(stack).toMatchArray(expectedStack);
     });
     it("subtracts (negative result)", function () {
-      var stack = evaluate("{ 4 6 sub }");
-      var expectedStack = [-2];
+      const stack = evaluate("{ 4 6 sub }");
+      const expectedStack = [-2];
       expect(stack).toMatchArray(expectedStack);
     });
     it("pushes true onto the stack", function () {
-      var stack = evaluate("{ true }");
-      var expectedStack = [true];
+      const stack = evaluate("{ true }");
+      const expectedStack = [true];
       expect(stack).toMatchArray(expectedStack);
     });
     it("truncates a number", function () {
-      var stack = evaluate("{ 35.004 truncate }");
-      var expectedStack = [35];
+      const stack = evaluate("{ 35.004 truncate }");
+      const expectedStack = [35];
       expect(stack).toMatchArray(expectedStack);
     });
     it("calculates an exclusive or value", function () {
-      var stack = evaluate("{ 3 9 xor }");
-      var expectedStack = [10];
+      const stack = evaluate("{ 3 9 xor }");
+      const expectedStack = [10];
       expect(stack).toMatchArray(expectedStack);
     });
   });
   describe("PostScriptCompiler", function () {
     function check(code, domain, range, samples) {
-      var compiler = new _function.PostScriptCompiler();
-      var compiledCode = compiler.compile(code, domain, range);
+      const compiler = new _function.PostScriptCompiler();
+      const compiledCode = compiler.compile(code, domain, range);
 
       if (samples === null) {
         expect(compiledCode).toBeNull();
       } else {
         expect(compiledCode).not.toBeNull();
-        var fn = new Function("src", "srcOffset", "dest", "destOffset", compiledCode);
+        const fn = new Function("src", "srcOffset", "dest", "destOffset", compiledCode);
 
-        for (var i = 0; i < samples.length; i++) {
-          var out = new Float32Array(samples[i].output.length);
+        for (let i = 0; i < samples.length; i++) {
+          const out = new Float32Array(samples[i].output.length);
           fn(samples[i].input, 0, out, 0);
           expect(Array.prototype.slice.call(out, 0)).toMatchArray(samples[i].output);
         }
@@ -636,9 +636,9 @@ describe("function", function () {
       }]);
     });
     it("compile optimized", function () {
-      var compiler = new _function.PostScriptCompiler();
-      var code = [0, "add", 1, 1, 3, -1, "roll", "sub", "sub", 1, "mul"];
-      var compiledCode = compiler.compile(code, [0, 1], [0, 1]);
+      const compiler = new _function.PostScriptCompiler();
+      const code = [0, "add", 1, 1, 3, -1, "roll", "sub", "sub", 1, "mul"];
+      const compiledCode = compiler.compile(code, [0, 1], [0, 1]);
       expect(compiledCode).toEqual("dest[destOffset + 0] = Math.max(0, Math.min(1, src[srcOffset + 0]));");
     });
   });