pdfjs-dist 2.1.266 → 2.5.207

package/lib/test/unit/function_spec.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2018 Mozilla Foundation
+ * Copyright 2020 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,23 +21,23 @@
  */
 "use strict";
 
-var _function = require("../../core/function");
+var _function = require("../../core/function.js");
 
-var _ps_parser = require("../../core/ps_parser");
+var _ps_parser = require("../../core/ps_parser.js");
 
-var _stream = require("../../core/stream");
+var _stream = require("../../core/stream.js");
 
-describe('function', function () {
+describe("function", function () {
   beforeEach(function () {
     jasmine.addMatchers({
-      toMatchArray: function toMatchArray(util, customEqualityTesters) {
+      toMatchArray(util, customEqualityTesters) {
         return {
-          compare: function compare(actual, expected) {
+          compare(actual, expected) {
             var result = {};
 
             if (actual.length !== expected.length) {
               result.pass = false;
-              result.message = 'Array length: ' + actual.length + ', expected: ' + expected.length;
+              result.message = "Array length: " + actual.length + ", expected: " + expected.length;
               return result;
             }
 
@@ -72,67 +72,69 @@ describe('function', function () {
 
             return result;
           }
+
         };
       }
+
     });
   });
-  describe('PostScriptParser', function () {
+  describe("PostScriptParser", function () {
     function parse(program) {
       var stream = new _stream.StringStream(program);
       var parser = new _ps_parser.PostScriptParser(new _ps_parser.PostScriptLexer(stream));
       return parser.parse();
     }
 
-    it('parses empty programs', function () {
-      var output = parse('{}');
+    it("parses empty programs", function () {
+      var output = parse("{}");
       expect(output.length).toEqual(0);
     });
-    it('parses positive numbers', function () {
+    it("parses positive numbers", function () {
       var number = 999;
-      var program = parse('{ ' + number + ' }');
+      var program = parse("{ " + number + " }");
       var expectedProgram = [number];
       expect(program).toMatchArray(expectedProgram);
     });
-    it('parses negative numbers', function () {
+    it("parses negative numbers", function () {
       var number = -999;
-      var program = parse('{ ' + number + ' }');
+      var program = parse("{ " + number + " }");
       var expectedProgram = [number];
       expect(program).toMatchArray(expectedProgram);
     });
-    it('parses negative floats', function () {
+    it("parses negative floats", function () {
       var number = 3.3;
-      var program = parse('{ ' + number + ' }');
+      var program = parse("{ " + number + " }");
       var expectedProgram = [number];
       expect(program).toMatchArray(expectedProgram);
     });
-    it('parses operators', function () {
-      var program = parse('{ sub }');
-      var expectedProgram = ['sub'];
+    it("parses operators", function () {
+      var program = parse("{ sub }");
+      var expectedProgram = ["sub"];
       expect(program).toMatchArray(expectedProgram);
     });
-    it('parses if statements', function () {
-      var program = parse('{ { 99 } if }');
-      var expectedProgram = [3, 'jz', 99];
+    it("parses if statements", function () {
+      var program = parse("{ { 99 } if }");
+      var 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];
+    it("parses ifelse statements", function () {
+      var program = parse("{ { 99 } { 44 } ifelse }");
+      var expectedProgram = [5, "jz", 99, 6, "j", 44];
       expect(program).toMatchArray(expectedProgram);
     });
-    it('handles missing brackets', function () {
+    it("handles missing brackets", function () {
       expect(function () {
-        parse('{');
-      }).toThrow(new Error('Unexpected symbol: found undefined expected 1.'));
+        parse("{");
+      }).toThrow(new Error("Unexpected symbol: found undefined expected 1."));
     });
-    it('handles junk after the end', function () {
+    it("handles junk after the end", function () {
       var number = 3.3;
-      var program = parse('{ ' + number + ' }#');
+      var program = parse("{ " + number + " }#");
       var expectedProgram = [number];
       expect(program).toMatchArray(expectedProgram);
     });
   });
-  describe('PostScriptEvaluator', function () {
+  describe("PostScriptEvaluator", function () {
     function evaluate(program) {
       var stream = new _stream.StringStream(program);
       var parser = new _ps_parser.PostScriptParser(new _ps_parser.PostScriptLexer(stream));
@@ -142,318 +144,318 @@ describe('function', function () {
       return output;
     }
 
-    it('pushes stack', function () {
-      var stack = evaluate('{ 99 }');
+    it("pushes stack", function () {
+      var stack = evaluate("{ 99 }");
       var expectedStack = [99];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('handles if with true', function () {
-      var stack = evaluate('{ 1 {99} if }');
+    it("handles if with true", function () {
+      var stack = evaluate("{ 1 {99} if }");
       var expectedStack = [99];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('handles if with false', function () {
-      var stack = evaluate('{ 0 {99} if }');
+    it("handles if with false", function () {
+      var stack = evaluate("{ 0 {99} if }");
       var expectedStack = [];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('handles ifelse with true', function () {
-      var stack = evaluate('{ 1 {99} {77} ifelse }');
+    it("handles ifelse with true", function () {
+      var stack = evaluate("{ 1 {99} {77} ifelse }");
       var expectedStack = [99];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('handles ifelse with false', function () {
-      var stack = evaluate('{ 0 {99} {77} ifelse }');
+    it("handles ifelse with false", function () {
+      var stack = evaluate("{ 0 {99} {77} ifelse }");
       var expectedStack = [77];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('handles nested if', function () {
-      var stack = evaluate('{ 1 {1 {77} if} if }');
+    it("handles nested if", function () {
+      var stack = evaluate("{ 1 {1 {77} if} if }");
       var expectedStack = [77];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('abs', function () {
-      var stack = evaluate('{ -2 abs }');
+    it("abs", function () {
+      var stack = evaluate("{ -2 abs }");
       var expectedStack = [2];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('adds', function () {
-      var stack = evaluate('{ 1 2 add }');
+    it("adds", function () {
+      var stack = evaluate("{ 1 2 add }");
       var expectedStack = [3];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('boolean and', function () {
-      var stack = evaluate('{ true false and }');
+    it("boolean and", function () {
+      var stack = evaluate("{ true false and }");
       var expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('bitwise and', function () {
-      var stack = evaluate('{ 254 1 and }');
+    it("bitwise and", function () {
+      var stack = evaluate("{ 254 1 and }");
       var expectedStack = [254 & 1];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('calculates the inverse tangent of a number', function () {
-      var stack = evaluate('{ 90 atan }');
+    it("calculates the inverse tangent of a number", function () {
+      var stack = evaluate("{ 90 atan }");
       var expectedStack = [Math.atan(90)];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('handles bitshifting ', function () {
-      var stack = evaluate('{ 50 2 bitshift }');
+    it("handles bitshifting ", function () {
+      var stack = evaluate("{ 50 2 bitshift }");
       var expectedStack = [200];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('calculates the ceiling value', function () {
-      var stack = evaluate('{ 9.9 ceiling }');
+    it("calculates the ceiling value", function () {
+      var stack = evaluate("{ 9.9 ceiling }");
       var expectedStack = [10];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('copies', function () {
-      var stack = evaluate('{ 99 98 2 copy }');
+    it("copies", function () {
+      var stack = evaluate("{ 99 98 2 copy }");
       var expectedStack = [99, 98, 99, 98];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('calculates the cosine of a number', function () {
-      var stack = evaluate('{ 90 cos }');
+    it("calculates the cosine of a number", function () {
+      var stack = evaluate("{ 90 cos }");
       var expectedStack = [Math.cos(90)];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('converts to int', function () {
-      var stack = evaluate('{ 9.9 cvi }');
+    it("converts to int", function () {
+      var stack = evaluate("{ 9.9 cvi }");
       var expectedStack = [9];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('converts negatives to int', function () {
-      var stack = evaluate('{ -9.9 cvi }');
+    it("converts negatives to int", function () {
+      var stack = evaluate("{ -9.9 cvi }");
       var expectedStack = [-9];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('converts to real', function () {
-      var stack = evaluate('{ 55.34 cvr }');
+    it("converts to real", function () {
+      var stack = evaluate("{ 55.34 cvr }");
       var expectedStack = [55.34];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('divides', function () {
-      var stack = evaluate('{ 6 5 div }');
+    it("divides", function () {
+      var stack = evaluate("{ 6 5 div }");
       var expectedStack = [1.2];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('maps division by zero to infinity', function () {
-      var stack = evaluate('{ 6 0 div }');
+    it("maps division by zero to infinity", function () {
+      var stack = evaluate("{ 6 0 div }");
       var expectedStack = [Infinity];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('duplicates', function () {
-      var stack = evaluate('{ 99 dup }');
+    it("duplicates", function () {
+      var stack = evaluate("{ 99 dup }");
       var expectedStack = [99, 99];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('accepts an equality', function () {
-      var stack = evaluate('{ 9 9 eq }');
+    it("accepts an equality", function () {
+      var stack = evaluate("{ 9 9 eq }");
       var expectedStack = [true];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('rejects an inequality', function () {
-      var stack = evaluate('{ 9 8 eq }');
+    it("rejects an inequality", function () {
+      var stack = evaluate("{ 9 8 eq }");
       var expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('exchanges', function () {
-      var stack = evaluate('{ 44 99 exch }');
+    it("exchanges", function () {
+      var stack = evaluate("{ 44 99 exch }");
       var expectedStack = [99, 44];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('handles exponentiation', function () {
-      var stack = evaluate('{ 10 2 exp }');
+    it("handles exponentiation", function () {
+      var stack = evaluate("{ 10 2 exp }");
       var expectedStack = [100];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('pushes false onto the stack', function () {
-      var stack = evaluate('{ false }');
+    it("pushes false onto the stack", function () {
+      var stack = evaluate("{ false }");
       var expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('calculates the floor value', function () {
-      var stack = evaluate('{ 9.9 floor }');
+    it("calculates the floor value", function () {
+      var stack = evaluate("{ 9.9 floor }");
       var expectedStack = [9];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('handles greater than or equal to', function () {
-      var stack = evaluate('{ 10 9 ge }');
+    it("handles greater than or equal to", function () {
+      var stack = evaluate("{ 10 9 ge }");
       var expectedStack = [true];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('rejects less than for greater than or equal to', function () {
-      var stack = evaluate('{ 8 9 ge }');
+    it("rejects less than for greater than or equal to", function () {
+      var stack = evaluate("{ 8 9 ge }");
       var expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('handles greater than', function () {
-      var stack = evaluate('{ 10 9 gt }');
+    it("handles greater than", function () {
+      var stack = evaluate("{ 10 9 gt }");
       var expectedStack = [true];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('rejects less than or equal for greater than', function () {
-      var stack = evaluate('{ 9 9 gt }');
+    it("rejects less than or equal for greater than", function () {
+      var stack = evaluate("{ 9 9 gt }");
       var expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('divides to integer', function () {
-      var stack = evaluate('{ 2 3 idiv }');
+    it("divides to integer", function () {
+      var stack = evaluate("{ 2 3 idiv }");
       var expectedStack = [0];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('divides to negative integer', function () {
-      var stack = evaluate('{ -2 3 idiv }');
+    it("divides to negative integer", function () {
+      var stack = evaluate("{ -2 3 idiv }");
       var expectedStack = [0];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('duplicates index', function () {
-      var stack = evaluate('{ 4 3 2 1 2 index }');
+    it("duplicates index", function () {
+      var stack = evaluate("{ 4 3 2 1 2 index }");
       var expectedStack = [4, 3, 2, 1, 3];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('handles less than or equal to', function () {
-      var stack = evaluate('{ 9 10 le }');
+    it("handles less than or equal to", function () {
+      var stack = evaluate("{ 9 10 le }");
       var expectedStack = [true];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('rejects greater than for less than or equal to', function () {
-      var stack = evaluate('{ 10 9 le }');
+    it("rejects greater than for less than or equal to", function () {
+      var stack = evaluate("{ 10 9 le }");
       var expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('calculates the natural logarithm', function () {
-      var stack = evaluate('{ 10 ln }');
+    it("calculates the natural logarithm", function () {
+      var stack = evaluate("{ 10 ln }");
       var expectedStack = [Math.log(10)];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('calculates the base 10 logarithm', function () {
-      var stack = evaluate('{ 100 log }');
+    it("calculates the base 10 logarithm", function () {
+      var stack = evaluate("{ 100 log }");
       var expectedStack = [2];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('handles less than', function () {
-      var stack = evaluate('{ 9 10 lt }');
+    it("handles less than", function () {
+      var stack = evaluate("{ 9 10 lt }");
       var expectedStack = [true];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('rejects greater than or equal to for less than', function () {
-      var stack = evaluate('{ 10 9 lt }');
+    it("rejects greater than or equal to for less than", function () {
+      var stack = evaluate("{ 10 9 lt }");
       var expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('performs the modulo operation', function () {
-      var stack = evaluate('{ 4 3 mod }');
+    it("performs the modulo operation", function () {
+      var stack = evaluate("{ 4 3 mod }");
       var expectedStack = [1];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('multiplies two numbers (positive result)', function () {
-      var stack = evaluate('{ 9 8 mul }');
+    it("multiplies two numbers (positive result)", function () {
+      var stack = evaluate("{ 9 8 mul }");
       var expectedStack = [72];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('multiplies two numbers (negative result)', function () {
-      var stack = evaluate('{ 9 -8 mul }');
+    it("multiplies two numbers (negative result)", function () {
+      var stack = evaluate("{ 9 -8 mul }");
       var expectedStack = [-72];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('accepts an inequality', function () {
-      var stack = evaluate('{ 9 8 ne }');
+    it("accepts an inequality", function () {
+      var stack = evaluate("{ 9 8 ne }");
       var expectedStack = [true];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('rejects an equality', function () {
-      var stack = evaluate('{ 9 9 ne }');
+    it("rejects an equality", function () {
+      var stack = evaluate("{ 9 9 ne }");
       var expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('negates', function () {
-      var stack = evaluate('{ 4.5 neg }');
+    it("negates", function () {
+      var stack = evaluate("{ 4.5 neg }");
       var expectedStack = [-4.5];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('boolean not', function () {
-      var stack = evaluate('{ true not }');
+    it("boolean not", function () {
+      var stack = evaluate("{ true not }");
       var expectedStack = [false];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('bitwise not', function () {
-      var stack = evaluate('{ 12 not }');
+    it("bitwise not", function () {
+      var stack = evaluate("{ 12 not }");
       var expectedStack = [-13];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('boolean or', function () {
-      var stack = evaluate('{ true false or }');
+    it("boolean or", function () {
+      var stack = evaluate("{ true false or }");
       var expectedStack = [true];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('bitwise or', function () {
-      var stack = evaluate('{ 254 1 or }');
+    it("bitwise or", function () {
+      var stack = evaluate("{ 254 1 or }");
       var expectedStack = [254 | 1];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('pops stack', function () {
-      var stack = evaluate('{ 1 2 pop }');
+    it("pops stack", function () {
+      var stack = evaluate("{ 1 2 pop }");
       var expectedStack = [1];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('rolls stack right', function () {
-      var stack = evaluate('{ 1 3 2 2 4 1 roll }');
+    it("rolls stack right", function () {
+      var stack = evaluate("{ 1 3 2 2 4 1 roll }");
       var expectedStack = [2, 1, 3, 2];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('rolls stack left', function () {
-      var stack = evaluate('{ 1 3 2 2 4 -1 roll }');
+    it("rolls stack left", function () {
+      var stack = evaluate("{ 1 3 2 2 4 -1 roll }");
       var expectedStack = [3, 2, 2, 1];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('rounds a number', function () {
-      var stack = evaluate('{ 9.52 round }');
+    it("rounds a number", function () {
+      var stack = evaluate("{ 9.52 round }");
       var expectedStack = [10];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('calculates the sine of a number', function () {
-      var stack = evaluate('{ 90 sin }');
+    it("calculates the sine of a number", function () {
+      var stack = evaluate("{ 90 sin }");
       var expectedStack = [Math.sin(90)];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('calculates a square root (integer)', function () {
-      var stack = evaluate('{ 100 sqrt }');
+    it("calculates a square root (integer)", function () {
+      var stack = evaluate("{ 100 sqrt }");
       var expectedStack = [10];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('calculates a square root (float)', function () {
-      var stack = evaluate('{ 99 sqrt }');
+    it("calculates a square root (float)", function () {
+      var stack = evaluate("{ 99 sqrt }");
       var expectedStack = [Math.sqrt(99)];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('subtracts (positive result)', function () {
-      var stack = evaluate('{ 6 4 sub }');
+    it("subtracts (positive result)", function () {
+      var stack = evaluate("{ 6 4 sub }");
       var expectedStack = [2];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('subtracts (negative result)', function () {
-      var stack = evaluate('{ 4 6 sub }');
+    it("subtracts (negative result)", function () {
+      var stack = evaluate("{ 4 6 sub }");
       var expectedStack = [-2];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('pushes true onto the stack', function () {
-      var stack = evaluate('{ true }');
+    it("pushes true onto the stack", function () {
+      var stack = evaluate("{ true }");
       var expectedStack = [true];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('truncates a number', function () {
-      var stack = evaluate('{ 35.004 truncate }');
+    it("truncates a number", function () {
+      var stack = evaluate("{ 35.004 truncate }");
       var expectedStack = [35];
       expect(stack).toMatchArray(expectedStack);
     });
-    it('calculates an exclusive or value', function () {
-      var stack = evaluate('{ 3 9 xor }');
+    it("calculates an exclusive or value", function () {
+      var stack = evaluate("{ 3 9 xor }");
       var expectedStack = [10];
       expect(stack).toMatchArray(expectedStack);
     });
   });
-  describe('PostScriptCompiler', function () {
+  describe("PostScriptCompiler", function () {
     function check(code, domain, range, samples) {
       var compiler = new _function.PostScriptCompiler();
       var compiledCode = compiler.compile(code, domain, range);
@@ -462,7 +464,7 @@ describe('function', function () {
         expect(compiledCode).toBeNull();
       } else {
         expect(compiledCode).not.toBeNull();
-        var fn = new Function('src', 'srcOffset', 'dest', 'destOffset', compiledCode);
+        var fn = new Function("src", "srcOffset", "dest", "destOffset", compiledCode);
 
         for (var i = 0; i < samples.length; i++) {
           var out = new Float32Array(samples[i].output.length);
@@ -472,132 +474,132 @@ describe('function', function () {
       }
     }
 
-    it('check compiled add', function () {
-      check([0.25, 0.5, 'add'], [], [0, 1], [{
+    it("check compiled add", function () {
+      check([0.25, 0.5, "add"], [], [0, 1], [{
         input: [],
         output: [0.75]
       }]);
-      check([0, 'add'], [0, 1], [0, 1], [{
+      check([0, "add"], [0, 1], [0, 1], [{
         input: [0.25],
         output: [0.25]
       }]);
-      check([0.5, 'add'], [0, 1], [0, 1], [{
+      check([0.5, "add"], [0, 1], [0, 1], [{
         input: [0.25],
         output: [0.75]
       }]);
-      check([0, 'exch', 'add'], [0, 1], [0, 1], [{
+      check([0, "exch", "add"], [0, 1], [0, 1], [{
         input: [0.25],
         output: [0.25]
       }]);
-      check([0.5, 'exch', 'add'], [0, 1], [0, 1], [{
+      check([0.5, "exch", "add"], [0, 1], [0, 1], [{
         input: [0.25],
         output: [0.75]
       }]);
-      check(['add'], [0, 1, 0, 1], [0, 1], [{
+      check(["add"], [0, 1, 0, 1], [0, 1], [{
         input: [0.25, 0.5],
         output: [0.75]
       }]);
-      check(['add'], [0, 1], [0, 1], null);
+      check(["add"], [0, 1], [0, 1], null);
     });
-    it('check compiled sub', function () {
-      check([0.5, 0.25, 'sub'], [], [0, 1], [{
+    it("check compiled sub", function () {
+      check([0.5, 0.25, "sub"], [], [0, 1], [{
         input: [],
         output: [0.25]
       }]);
-      check([0, 'sub'], [0, 1], [0, 1], [{
+      check([0, "sub"], [0, 1], [0, 1], [{
         input: [0.25],
         output: [0.25]
       }]);
-      check([0.5, 'sub'], [0, 1], [0, 1], [{
+      check([0.5, "sub"], [0, 1], [0, 1], [{
         input: [0.75],
         output: [0.25]
       }]);
-      check([0, 'exch', 'sub'], [0, 1], [-1, 1], [{
+      check([0, "exch", "sub"], [0, 1], [-1, 1], [{
         input: [0.25],
         output: [-0.25]
       }]);
-      check([0.75, 'exch', 'sub'], [0, 1], [-1, 1], [{
+      check([0.75, "exch", "sub"], [0, 1], [-1, 1], [{
         input: [0.25],
         output: [0.5]
       }]);
-      check(['sub'], [0, 1, 0, 1], [-1, 1], [{
+      check(["sub"], [0, 1, 0, 1], [-1, 1], [{
         input: [0.25, 0.5],
         output: [-0.25]
       }]);
-      check(['sub'], [0, 1], [0, 1], null);
-      check([1, 'dup', 3, 2, 'roll', 'sub', 'sub'], [0, 1], [0, 1], [{
+      check(["sub"], [0, 1], [0, 1], null);
+      check([1, "dup", 3, 2, "roll", "sub", "sub"], [0, 1], [0, 1], [{
         input: [0.75],
         output: [0.75]
       }]);
     });
-    it('check compiled mul', function () {
-      check([0.25, 0.5, 'mul'], [], [0, 1], [{
+    it("check compiled mul", function () {
+      check([0.25, 0.5, "mul"], [], [0, 1], [{
         input: [],
         output: [0.125]
       }]);
-      check([0, 'mul'], [0, 1], [0, 1], [{
+      check([0, "mul"], [0, 1], [0, 1], [{
         input: [0.25],
         output: [0]
       }]);
-      check([0.5, 'mul'], [0, 1], [0, 1], [{
+      check([0.5, "mul"], [0, 1], [0, 1], [{
         input: [0.25],
         output: [0.125]
       }]);
-      check([1, 'mul'], [0, 1], [0, 1], [{
+      check([1, "mul"], [0, 1], [0, 1], [{
         input: [0.25],
         output: [0.25]
       }]);
-      check([0, 'exch', 'mul'], [0, 1], [0, 1], [{
+      check([0, "exch", "mul"], [0, 1], [0, 1], [{
         input: [0.25],
         output: [0]
       }]);
-      check([0.5, 'exch', 'mul'], [0, 1], [0, 1], [{
+      check([0.5, "exch", "mul"], [0, 1], [0, 1], [{
         input: [0.25],
         output: [0.125]
       }]);
-      check([1, 'exch', 'mul'], [0, 1], [0, 1], [{
+      check([1, "exch", "mul"], [0, 1], [0, 1], [{
         input: [0.25],
         output: [0.25]
       }]);
-      check(['mul'], [0, 1, 0, 1], [0, 1], [{
+      check(["mul"], [0, 1, 0, 1], [0, 1], [{
         input: [0.25, 0.5],
         output: [0.125]
       }]);
-      check(['mul'], [0, 1], [0, 1], null);
+      check(["mul"], [0, 1], [0, 1], null);
     });
-    it('check compiled max', function () {
-      check(['dup', 0.75, 'gt', 7, 'jz', 'pop', 0.75], [0, 1], [0, 1], [{
+    it("check compiled max", function () {
+      check(["dup", 0.75, "gt", 7, "jz", "pop", 0.75], [0, 1], [0, 1], [{
         input: [0.5],
         output: [0.5]
       }]);
-      check(['dup', 0.75, 'gt', 7, 'jz', 'pop', 0.75], [0, 1], [0, 1], [{
+      check(["dup", 0.75, "gt", 7, "jz", "pop", 0.75], [0, 1], [0, 1], [{
         input: [1],
         output: [0.75]
       }]);
-      check(['dup', 0.75, 'gt', 5, 'jz', 'pop', 0.75], [0, 1], [0, 1], null);
+      check(["dup", 0.75, "gt", 5, "jz", "pop", 0.75], [0, 1], [0, 1], null);
     });
-    it('check pop/roll/index', function () {
-      check([1, 'pop'], [0, 1], [0, 1], [{
+    it("check pop/roll/index", function () {
+      check([1, "pop"], [0, 1], [0, 1], [{
         input: [0.5],
         output: [0.5]
       }]);
-      check([1, 3, -1, 'roll'], [0, 1, 0, 1], [0, 1, 0, 1, 0, 1], [{
+      check([1, 3, -1, "roll"], [0, 1, 0, 1], [0, 1, 0, 1, 0, 1], [{
         input: [0.25, 0.5],
         output: [0.5, 1, 0.25]
       }]);
-      check([1, 3, 1, 'roll'], [0, 1, 0, 1], [0, 1, 0, 1, 0, 1], [{
+      check([1, 3, 1, "roll"], [0, 1, 0, 1], [0, 1, 0, 1, 0, 1], [{
         input: [0.25, 0.5],
         output: [1, 0.25, 0.5]
       }]);
-      check([1, 3, 1.5, 'roll'], [0, 1, 0, 1], [0, 1, 0, 1, 0, 1], null);
-      check([1, 1, 'index'], [0, 1], [0, 1, 0, 1, 0, 1], [{
+      check([1, 3, 1.5, "roll"], [0, 1, 0, 1], [0, 1, 0, 1, 0, 1], null);
+      check([1, 1, "index"], [0, 1], [0, 1, 0, 1, 0, 1], [{
         input: [0.5],
         output: [0.5, 1, 0.5]
       }]);
-      check([1, 3, 'index', 'pop'], [0, 1], [0, 1], null);
-      check([1, 0.5, 'index', 'pop'], [0, 1], [0, 1], null);
+      check([1, 3, "index", "pop"], [0, 1], [0, 1], null);
+      check([1, 0.5, "index", "pop"], [0, 1], [0, 1], null);
     });
-    it('check input boundaries', function () {
+    it("check input boundaries", function () {
       check([], [0, 0.5], [0, 1], [{
         input: [1],
         output: [0.5]
@@ -606,7 +608,7 @@ describe('function', function () {
         input: [0],
         output: [0.5]
       }]);
-      check(['dup'], [0.5, 0.75], [0, 1, 0, 1], [{
+      check(["dup"], [0.5, 0.75], [0, 1, 0, 1], [{
         input: [0],
         output: [0.5, 0.5]
       }]);
@@ -615,7 +617,7 @@ describe('function', function () {
         output: [1000]
       }]);
     });
-    it('check output boundaries', function () {
+    it("check output boundaries", function () {
       check([], [0, 1], [0, 0.5], [{
         input: [1],
         output: [0.5]
@@ -624,7 +626,7 @@ describe('function', function () {
         input: [0],
         output: [0.5]
       }]);
-      check(['dup'], [0, 1], [0.5, 1, 0.75, 1], [{
+      check(["dup"], [0, 1], [0.5, 1, 0.75, 1], [{
         input: [0],
         output: [0.5, 0.75]
       }]);
@@ -633,11 +635,11 @@ describe('function', function () {
         output: [1000]
       }]);
     });
-    it('compile optimized', function () {
+    it("compile optimized", function () {
       var compiler = new _function.PostScriptCompiler();
-      var code = [0, 'add', 1, 1, 3, -1, 'roll', 'sub', 'sub', 1, 'mul'];
+      var code = [0, "add", 1, 1, 3, -1, "roll", "sub", "sub", 1, "mul"];
       var compiledCode = compiler.compile(code, [0, 1], [0, 1]);
-      expect(compiledCode).toEqual('dest[destOffset + 0] = Math.max(0, Math.min(1, src[srcOffset + 0]));');
+      expect(compiledCode).toEqual("dest[destOffset + 0] = Math.max(0, Math.min(1, src[srcOffset + 0]));");
     });
   });
 });