pdfjs-dist 2.0.489 → 2.2.228

package/lib/core/function.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2017 Mozilla Foundation
+ * Copyright 2019 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,36 +19,42 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.PostScriptCompiler = exports.PostScriptEvaluator = exports.PDFFunctionFactory = exports.isPDFFunction = undefined;
-
-var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function (obj) { return typeof obj; } : function (obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; };
+exports.isPDFFunction = isPDFFunction;
+exports.PostScriptCompiler = exports.PostScriptEvaluator = exports.PDFFunctionFactory = void 0;
 
-var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
+var _util = require("../shared/util");
 
-var _util = require('../shared/util');
+var _primitives = require("./primitives");
 
-var _primitives = require('./primitives');
+var _ps_parser = require("./ps_parser");
 
-var _ps_parser = require('./ps_parser');
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
 
 function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
 var IsEvalSupportedCached = {
   get value() {
     return (0, _util.shadow)(this, 'value', (0, _util.isEvalSupported)());
   }
+
 };
 
-var PDFFunctionFactory = function () {
+var PDFFunctionFactory =
+/*#__PURE__*/
+function () {
   function PDFFunctionFactory(_ref) {
     var xref = _ref.xref,
         _ref$isEvalSupported = _ref.isEvalSupported,
-        isEvalSupported = _ref$isEvalSupported === undefined ? true : _ref$isEvalSupported;
+        isEvalSupported = _ref$isEvalSupported === void 0 ? true : _ref$isEvalSupported;
 
     _classCallCheck(this, PDFFunctionFactory);
 
@@ -57,7 +63,7 @@ var PDFFunctionFactory = function () {
   }
 
   _createClass(PDFFunctionFactory, [{
-    key: 'create',
+    key: "create",
     value: function create(fn) {
       return PDFFunction.parse({
         xref: this.xref,
@@ -66,7 +72,7 @@ var PDFFunctionFactory = function () {
       });
     }
   }, {
-    key: 'createFromArray',
+    key: "createFromArray",
     value: function createFromArray(fnObj) {
       return PDFFunction.parseArray({
         xref: this.xref,
@@ -74,29 +80,35 @@ var PDFFunctionFactory = function () {
         fnObj: fnObj
       });
     }
-  }, {
-    key: 'createFromIR',
-    value: function createFromIR(IR) {
-      return PDFFunction.fromIR({
-        xref: this.xref,
-        isEvalSupported: this.isEvalSupported,
-        IR: IR
-      });
-    }
-  }, {
-    key: 'createIR',
-    value: function createIR(fn) {
-      return PDFFunction.getIR({
-        xref: this.xref,
-        isEvalSupported: this.isEvalSupported,
-        fn: fn
-      });
-    }
   }]);
 
   return PDFFunctionFactory;
 }();
 
+exports.PDFFunctionFactory = PDFFunctionFactory;
+
+function toNumberArray(arr) {
+  if (!Array.isArray(arr)) {
+    return null;
+  }
+
+  var length = arr.length;
+
+  for (var i = 0; i < length; i++) {
+    if (typeof arr[i] !== 'number') {
+      var result = new Array(length);
+
+      for (var _i = 0; _i < length; _i++) {
+        result[_i] = +arr[_i];
+      }
+
+      return result;
+    }
+  }
+
+  return arr;
+}
+
 var PDFFunction = function PDFFunctionClosure() {
   var CONSTRUCT_SAMPLED = 0;
   var CONSTRUCT_INTERPOLATED = 2;
@@ -106,9 +118,11 @@ var PDFFunction = function PDFFunctionClosure() {
     getSampleArray: function getSampleArray(size, outputSize, bps, stream) {
       var i, ii;
       var length = 1;
+
       for (i = 0, ii = size.length; i < ii; i++) {
         length *= size[i];
       }
+
       length *= outputSize;
       var array = new Array(length);
       var codeSize = 0;
@@ -116,33 +130,39 @@ var PDFFunction = function PDFFunctionClosure() {
       var sampleMul = 1.0 / (Math.pow(2.0, bps) - 1);
       var strBytes = stream.getBytes((length * bps + 7) / 8);
       var strIdx = 0;
+
       for (i = 0; i < length; i++) {
         while (codeSize < bps) {
           codeBuf <<= 8;
           codeBuf |= strBytes[strIdx++];
           codeSize += 8;
         }
+
         codeSize -= bps;
         array[i] = (codeBuf >> codeSize) * sampleMul;
         codeBuf &= (1 << codeSize) - 1;
       }
+
       return array;
     },
     getIR: function getIR(_ref2) {
       var xref = _ref2.xref,
           isEvalSupported = _ref2.isEvalSupported,
           fn = _ref2.fn;
-
       var dict = fn.dict;
+
       if (!dict) {
         dict = fn;
       }
+
       var types = [this.constructSampled, null, this.constructInterpolated, this.constructStiched, this.constructPostScript];
       var typeNum = dict.get('FunctionType');
       var typeFn = types[typeNum];
+
       if (!typeFn) {
         throw new _util.FormatError('Unknown type of function');
       }
+
       return typeFn.call(this, {
         xref: xref,
         isEvalSupported: isEvalSupported,
@@ -154,8 +174,8 @@ var PDFFunction = function PDFFunctionClosure() {
       var xref = _ref3.xref,
           isEvalSupported = _ref3.isEvalSupported,
           IR = _ref3.IR;
-
       var type = IR[0];
+
       switch (type) {
         case CONSTRUCT_SAMPLED:
           return this.constructSampledFromIR({
@@ -163,18 +183,21 @@ var PDFFunction = function PDFFunctionClosure() {
             isEvalSupported: isEvalSupported,
             IR: IR
           });
+
         case CONSTRUCT_INTERPOLATED:
           return this.constructInterpolatedFromIR({
             xref: xref,
             isEvalSupported: isEvalSupported,
             IR: IR
           });
+
         case CONSTRUCT_STICHED:
           return this.constructStichedFromIR({
             xref: xref,
             isEvalSupported: isEvalSupported,
             IR: IR
           });
+
         default:
           return this.constructPostScriptFromIR({
             xref: xref,
@@ -187,7 +210,6 @@ var PDFFunction = function PDFFunctionClosure() {
       var xref = _ref4.xref,
           isEvalSupported = _ref4.isEvalSupported,
           fn = _ref4.fn;
-
       var IR = this.getIR({
         xref: xref,
         isEvalSupported: isEvalSupported,
@@ -211,7 +233,9 @@ var PDFFunction = function PDFFunctionClosure() {
           fn: fnObj
         });
       }
+
       var fnArray = [];
+
       for (var j = 0, jj = fnObj.length; j < jj; j++) {
         fnArray.push(this.parse({
           xref: xref,
@@ -219,6 +243,7 @@ var PDFFunction = function PDFFunctionClosure() {
           fn: xref.fetchIfRef(fnObj[j])
         }));
       }
+
       return function (src, srcOffset, dest, destOffset) {
         for (var i = 0, ii = fnArray.length; i < ii; i++) {
           fnArray[i](src, srcOffset, dest, destOffset + i);
@@ -235,42 +260,54 @@ var PDFFunction = function PDFFunctionClosure() {
         var inputLength = arr.length;
         var out = [];
         var index = 0;
+
         for (var i = 0; i < inputLength; i += 2) {
           out[index] = [arr[i], arr[i + 1]];
           ++index;
         }
+
         return out;
       }
-      var domain = dict.getArray('Domain');
-      var range = dict.getArray('Range');
+
+      var domain = toNumberArray(dict.getArray('Domain'));
+      var range = toNumberArray(dict.getArray('Range'));
+
       if (!domain || !range) {
         throw new _util.FormatError('No domain or range');
       }
+
       var inputSize = domain.length / 2;
       var outputSize = range.length / 2;
       domain = toMultiArray(domain);
       range = toMultiArray(range);
-      var size = dict.get('Size');
+      var size = toNumberArray(dict.getArray('Size'));
       var bps = dict.get('BitsPerSample');
       var order = dict.get('Order') || 1;
+
       if (order !== 1) {
         (0, _util.info)('No support for cubic spline interpolation: ' + order);
       }
-      var encode = dict.getArray('Encode');
+
+      var encode = toNumberArray(dict.getArray('Encode'));
+
       if (!encode) {
         encode = [];
+
         for (var i = 0; i < inputSize; ++i) {
-          encode.push(0);
-          encode.push(size[i] - 1);
+          encode.push([0, size[i] - 1]);
         }
+      } else {
+        encode = toMultiArray(encode);
       }
-      encode = toMultiArray(encode);
-      var decode = dict.getArray('Decode');
+
+      var decode = toNumberArray(dict.getArray('Decode'));
+
       if (!decode) {
         decode = range;
       } else {
         decode = toMultiArray(decode);
       }
+
       var samples = this.getSampleArray(size, outputSize, bps, fn);
       return [CONSTRUCT_SAMPLED, inputSize, domain, encode, decode, samples, size, outputSize, Math.pow(2, bps) - 1, range];
     },
@@ -282,6 +319,7 @@ var PDFFunction = function PDFFunctionClosure() {
       function interpolate(x, xmin, xmax, ymin, ymax) {
         return ymin + (x - xmin) * ((ymax - ymin) / (xmax - xmin));
       }
+
       return function constructSampledFromIRResult(src, srcOffset, dest, destOffset) {
         var m = IR[1];
         var domain = IR[2];
@@ -295,11 +333,14 @@ var PDFFunction = function PDFFunctionClosure() {
         var cubeN = new Float64Array(cubeVertices);
         var cubeVertex = new Uint32Array(cubeVertices);
         var i, j;
+
         for (j = 0; j < cubeVertices; j++) {
           cubeN[j] = 1;
         }
+
         var k = n,
             pos = 1;
+
         for (i = 0; i < m; ++i) {
           var domain_2i = domain[i][0];
           var domain_2i_1 = domain[i][1];
@@ -312,6 +353,7 @@ var PDFFunction = function PDFFunctionClosure() {
           var n1 = e - e0;
           var offset0 = e0 * k;
           var offset1 = offset0 + k;
+
           for (j = 0; j < cubeVertices; j++) {
             if (j & pos) {
               cubeN[j] *= n1;
@@ -321,14 +363,18 @@ var PDFFunction = function PDFFunctionClosure() {
               cubeVertex[j] += offset0;
             }
           }
+
           k *= size_i;
           pos <<= 1;
         }
+
         for (j = 0; j < n; ++j) {
           var rj = 0;
+
           for (i = 0; i < cubeVertices; i++) {
             rj += samples[cubeVertex[i] + j] * cubeN[i];
           }
+
           rj = interpolate(rj, 0, 1, decode[j][0], decode[j][1]);
           dest[destOffset + j] = Math.min(Math.max(rj, range[j][0]), range[j][1]);
         }
@@ -339,31 +385,29 @@ var PDFFunction = function PDFFunctionClosure() {
           isEvalSupported = _ref8.isEvalSupported,
           fn = _ref8.fn,
           dict = _ref8.dict;
-
-      var c0 = dict.getArray('C0') || [0];
-      var c1 = dict.getArray('C1') || [1];
+      var c0 = toNumberArray(dict.getArray('C0')) || [0];
+      var c1 = toNumberArray(dict.getArray('C1')) || [1];
       var n = dict.get('N');
-      if (!Array.isArray(c0) || !Array.isArray(c1)) {
-        throw new _util.FormatError('Illegal dictionary for interpolated function');
-      }
       var length = c0.length;
       var diff = [];
+
       for (var i = 0; i < length; ++i) {
         diff.push(c1[i] - c0[i]);
       }
+
       return [CONSTRUCT_INTERPOLATED, c0, diff, n];
     },
     constructInterpolatedFromIR: function constructInterpolatedFromIR(_ref9) {
       var xref = _ref9.xref,
           isEvalSupported = _ref9.isEvalSupported,
           IR = _ref9.IR;
-
       var c0 = IR[1];
       var diff = IR[2];
       var n = IR[3];
       var length = diff.length;
       return function constructInterpolatedFromIRResult(src, srcOffset, dest, destOffset) {
         var x = n === 1 ? src[srcOffset] : Math.pow(src[srcOffset], n);
+
         for (var j = 0; j < length; ++j) {
           dest[destOffset + j] = c0[j] + x * diff[j];
         }
@@ -374,46 +418,42 @@ var PDFFunction = function PDFFunctionClosure() {
           isEvalSupported = _ref10.isEvalSupported,
           fn = _ref10.fn,
           dict = _ref10.dict;
+      var domain = toNumberArray(dict.getArray('Domain'));
 
-      var domain = dict.getArray('Domain');
       if (!domain) {
         throw new _util.FormatError('No domain');
       }
+
       var inputSize = domain.length / 2;
+
       if (inputSize !== 1) {
         throw new _util.FormatError('Bad domain for stiched function');
       }
+
       var fnRefs = dict.get('Functions');
       var fns = [];
+
       for (var i = 0, ii = fnRefs.length; i < ii; ++i) {
-        fns.push(this.getIR({
+        fns.push(this.parse({
           xref: xref,
           isEvalSupported: isEvalSupported,
           fn: xref.fetchIfRef(fnRefs[i])
         }));
       }
-      var bounds = dict.getArray('Bounds');
-      var encode = dict.getArray('Encode');
+
+      var bounds = toNumberArray(dict.getArray('Bounds'));
+      var encode = toNumberArray(dict.getArray('Encode'));
       return [CONSTRUCT_STICHED, domain, bounds, encode, fns];
     },
     constructStichedFromIR: function constructStichedFromIR(_ref11) {
       var xref = _ref11.xref,
           isEvalSupported = _ref11.isEvalSupported,
           IR = _ref11.IR;
-
       var domain = IR[1];
       var bounds = IR[2];
       var encode = IR[3];
-      var fnsIR = IR[4];
-      var fns = [];
+      var fns = IR[4];
       var tmpBuf = new Float32Array(1);
-      for (var i = 0, ii = fnsIR.length; i < ii; i++) {
-        fns.push(this.fromIR({
-          xref: xref,
-          isEvalSupported: isEvalSupported,
-          IR: fnsIR[i]
-        }));
-      }
       return function constructStichedFromIRResult(src, srcOffset, dest, destOffset) {
         var clip = function constructStichedFromIRClip(v, min, max) {
           if (v > max) {
@@ -421,22 +461,30 @@ var PDFFunction = function PDFFunctionClosure() {
           } else if (v < min) {
             v = min;
           }
+
           return v;
         };
+
         var v = clip(src[srcOffset], domain[0], domain[1]);
+
         for (var i = 0, ii = bounds.length; i < ii; ++i) {
           if (v < bounds[i]) {
             break;
           }
         }
+
         var dmin = domain[0];
+
         if (i > 0) {
           dmin = bounds[i - 1];
         }
+
         var dmax = domain[1];
+
         if (i < bounds.length) {
           dmax = bounds[i];
         }
+
         var rmin = encode[2 * i];
         var rmax = encode[2 * i + 1];
         tmpBuf[0] = dmin === dmax ? rmin : rmin + (v - dmin) * (rmax - rmin) / (dmax - dmin);
@@ -448,15 +496,17 @@ var PDFFunction = function PDFFunctionClosure() {
           isEvalSupported = _ref12.isEvalSupported,
           fn = _ref12.fn,
           dict = _ref12.dict;
+      var domain = toNumberArray(dict.getArray('Domain'));
+      var range = toNumberArray(dict.getArray('Range'));
 
-      var domain = dict.getArray('Domain');
-      var range = dict.getArray('Range');
       if (!domain) {
         throw new _util.FormatError('No domain.');
       }
+
       if (!range) {
         throw new _util.FormatError('No range.');
       }
+
       var lexer = new _ps_parser.PostScriptLexer(fn);
       var parser = new _ps_parser.PostScriptParser(lexer);
       var code = parser.parse();
@@ -466,16 +516,18 @@ var PDFFunction = function PDFFunctionClosure() {
       var xref = _ref13.xref,
           isEvalSupported = _ref13.isEvalSupported,
           IR = _ref13.IR;
-
       var domain = IR[1];
       var range = IR[2];
       var code = IR[3];
+
       if (isEvalSupported && IsEvalSupportedCached.value) {
         var compiled = new PostScriptCompiler().compile(code, domain, range);
+
         if (compiled) {
           return new Function('src', 'srcOffset', 'dest', 'destOffset', compiled);
         }
       }
+
       (0, _util.info)('Unable to compile PS function');
       var numOutputs = range.length >> 1;
       var numInputs = domain.length >> 1;
@@ -488,44 +540,56 @@ var PDFFunction = function PDFFunctionClosure() {
         var i, value;
         var key = '';
         var input = tmpBuf;
+
         for (i = 0; i < numInputs; i++) {
           value = src[srcOffset + i];
           input[i] = value;
           key += value + '_';
         }
+
         var 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;
+
         for (i = 0; i < numOutputs; i++) {
           value = stack[stackIndex + i];
           var bound = range[i * 2];
+
           if (value < bound) {
             value = bound;
           } else {
             bound = range[i * 2 + 1];
+
             if (value > bound) {
               value = bound;
             }
           }
+
           output[i] = value;
         }
+
         if (cache_available > 0) {
           cache_available--;
           cache[key] = output;
         }
+
         dest.set(output, destOffset);
       };
     }
   };
 }();
+
 function isPDFFunction(v) {
   var fnDict;
-  if ((typeof v === 'undefined' ? 'undefined' : _typeof(v)) !== 'object') {
+
+  if (_typeof(v) !== 'object') {
     return false;
   } else if ((0, _primitives.isDict)(v)) {
     fnDict = v;
@@ -534,31 +598,39 @@ function isPDFFunction(v) {
   } else {
     return false;
   }
+
   return fnDict.has('FunctionType');
 }
+
 var PostScriptStack = function PostScriptStackClosure() {
   var MAX_STACK_SIZE = 100;
+
   function PostScriptStack(initialStack) {
     this.stack = !initialStack ? [] : Array.prototype.slice.call(initialStack, 0);
   }
+
   PostScriptStack.prototype = {
     push: function PostScriptStack_push(value) {
       if (this.stack.length >= MAX_STACK_SIZE) {
         throw new Error('PostScript function stack overflow.');
       }
+
       this.stack.push(value);
     },
     pop: function PostScriptStack_pop() {
       if (this.stack.length <= 0) {
         throw new Error('PostScript function stack underflow.');
       }
+
       return this.stack.pop();
     },
     copy: function PostScriptStack_copy(n) {
       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++) {
         stack.push(stack[i]);
       }
@@ -574,16 +646,19 @@ var PostScriptStack = function PostScriptStackClosure() {
           i,
           j,
           t;
+
       for (i = l, j = r; i < j; i++, j--) {
         t = stack[i];
         stack[i] = stack[j];
         stack[j] = t;
       }
+
       for (i = l, j = c - 1; i < j; i++, j--) {
         t = stack[i];
         stack[i] = stack[j];
         stack[j] = t;
       }
+
       for (i = c, j = r; i < j; i++, j--) {
         t = stack[i];
         stack[i] = stack[j];
@@ -593,10 +668,12 @@ var PostScriptStack = function PostScriptStackClosure() {
   };
   return PostScriptStack;
 }();
+
 var PostScriptEvaluator = function PostScriptEvaluatorClosure() {
   function PostScriptEvaluator(operators) {
     this.operators = operators;
   }
+
   PostScriptEvaluator.prototype = {
     execute: function PostScriptEvaluator_execute(initialStack) {
       var stack = new PostScriptStack(initialStack);
@@ -604,252 +681,321 @@ var PostScriptEvaluator = function PostScriptEvaluatorClosure() {
       var operators = this.operators;
       var length = operators.length;
       var operator, a, b;
+
       while (counter < length) {
         operator = operators[counter++];
+
         if (typeof operator === 'number') {
           stack.push(operator);
           continue;
         }
+
         switch (operator) {
           case 'jz':
             b = stack.pop();
             a = stack.pop();
+
             if (!a) {
               counter = b;
             }
+
             break;
+
           case 'j':
             a = stack.pop();
             counter = a;
             break;
+
           case 'abs':
             a = stack.pop();
             stack.push(Math.abs(a));
             break;
+
           case 'add':
             b = stack.pop();
             a = stack.pop();
             stack.push(a + b);
             break;
+
           case 'and':
             b = stack.pop();
             a = stack.pop();
+
             if ((0, _util.isBool)(a) && (0, _util.isBool)(b)) {
               stack.push(a && b);
             } else {
               stack.push(a & b);
             }
+
             break;
+
           case 'atan':
             a = stack.pop();
             stack.push(Math.atan(a));
             break;
+
           case 'bitshift':
             b = stack.pop();
             a = stack.pop();
+
             if (a > 0) {
               stack.push(a << b);
             } else {
               stack.push(a >> b);
             }
+
             break;
+
           case 'ceiling':
             a = stack.pop();
             stack.push(Math.ceil(a));
             break;
+
           case 'copy':
             a = stack.pop();
             stack.copy(a);
             break;
+
           case 'cos':
             a = stack.pop();
             stack.push(Math.cos(a));
             break;
+
           case 'cvi':
             a = stack.pop() | 0;
             stack.push(a);
             break;
+
           case 'cvr':
             break;
+
           case 'div':
             b = stack.pop();
             a = stack.pop();
             stack.push(a / b);
             break;
+
           case 'dup':
             stack.copy(1);
             break;
+
           case 'eq':
             b = stack.pop();
             a = stack.pop();
             stack.push(a === b);
             break;
+
           case 'exch':
             stack.roll(2, 1);
             break;
+
           case 'exp':
             b = stack.pop();
             a = stack.pop();
             stack.push(Math.pow(a, b));
             break;
+
           case 'false':
             stack.push(false);
             break;
+
           case 'floor':
             a = stack.pop();
             stack.push(Math.floor(a));
             break;
+
           case 'ge':
             b = stack.pop();
             a = stack.pop();
             stack.push(a >= b);
             break;
+
           case 'gt':
             b = stack.pop();
             a = stack.pop();
             stack.push(a > b);
             break;
+
           case 'idiv':
             b = stack.pop();
             a = stack.pop();
             stack.push(a / b | 0);
             break;
+
           case 'index':
             a = stack.pop();
             stack.index(a);
             break;
+
           case 'le':
             b = stack.pop();
             a = stack.pop();
             stack.push(a <= b);
             break;
+
           case 'ln':
             a = stack.pop();
             stack.push(Math.log(a));
             break;
+
           case 'log':
             a = stack.pop();
             stack.push(Math.log(a) / Math.LN10);
             break;
+
           case 'lt':
             b = stack.pop();
             a = stack.pop();
             stack.push(a < b);
             break;
+
           case 'mod':
             b = stack.pop();
             a = stack.pop();
             stack.push(a % b);
             break;
+
           case 'mul':
             b = stack.pop();
             a = stack.pop();
             stack.push(a * b);
             break;
+
           case 'ne':
             b = stack.pop();
             a = stack.pop();
             stack.push(a !== b);
             break;
+
           case 'neg':
             a = stack.pop();
             stack.push(-a);
             break;
+
           case 'not':
             a = stack.pop();
+
             if ((0, _util.isBool)(a)) {
               stack.push(!a);
             } else {
               stack.push(~a);
             }
+
             break;
+
           case 'or':
             b = stack.pop();
             a = stack.pop();
+
             if ((0, _util.isBool)(a) && (0, _util.isBool)(b)) {
               stack.push(a || b);
             } else {
               stack.push(a | b);
             }
+
             break;
+
           case 'pop':
             stack.pop();
             break;
+
           case 'roll':
             b = stack.pop();
             a = stack.pop();
             stack.roll(a, b);
             break;
+
           case 'round':
             a = stack.pop();
             stack.push(Math.round(a));
             break;
+
           case 'sin':
             a = stack.pop();
             stack.push(Math.sin(a));
             break;
+
           case 'sqrt':
             a = stack.pop();
             stack.push(Math.sqrt(a));
             break;
+
           case 'sub':
             b = stack.pop();
             a = stack.pop();
             stack.push(a - b);
             break;
+
           case 'true':
             stack.push(true);
             break;
+
           case 'truncate':
             a = stack.pop();
             a = a < 0 ? Math.ceil(a) : Math.floor(a);
             stack.push(a);
             break;
+
           case 'xor':
             b = stack.pop();
             a = stack.pop();
+
             if ((0, _util.isBool)(a) && (0, _util.isBool)(b)) {
               stack.push(a !== b);
             } else {
               stack.push(a ^ b);
             }
+
             break;
+
           default:
-            throw new _util.FormatError('Unknown operator ' + operator);
+            throw new _util.FormatError("Unknown operator ".concat(operator));
         }
       }
+
       return stack.stack;
     }
   };
   return PostScriptEvaluator;
 }();
+
+exports.PostScriptEvaluator = PostScriptEvaluator;
+
 var PostScriptCompiler = function PostScriptCompilerClosure() {
   function AstNode(type) {
     this.type = type;
   }
+
   AstNode.prototype.visit = function (visitor) {
     (0, _util.unreachable)('abstract method');
   };
+
   function AstArgument(index, min, max) {
     AstNode.call(this, 'args');
     this.index = index;
     this.min = min;
     this.max = max;
   }
+
   AstArgument.prototype = Object.create(AstNode.prototype);
+
   AstArgument.prototype.visit = function (visitor) {
     visitor.visitArgument(this);
   };
+
   function AstLiteral(number) {
     AstNode.call(this, 'literal');
     this.number = number;
     this.min = number;
     this.max = number;
   }
+
   AstLiteral.prototype = Object.create(AstNode.prototype);
+
   AstLiteral.prototype.visit = function (visitor) {
     visitor.visitLiteral(this);
   };
+
   function AstBinaryOperation(op, arg1, arg2, min, max) {
     AstNode.call(this, 'binary');
     this.op = op;
@@ -858,42 +1004,55 @@ var PostScriptCompiler = function PostScriptCompilerClosure() {
     this.min = min;
     this.max = max;
   }
+
   AstBinaryOperation.prototype = Object.create(AstNode.prototype);
+
   AstBinaryOperation.prototype.visit = function (visitor) {
     visitor.visitBinaryOperation(this);
   };
+
   function AstMin(arg, max) {
     AstNode.call(this, 'max');
     this.arg = arg;
     this.min = arg.min;
     this.max = max;
   }
+
   AstMin.prototype = Object.create(AstNode.prototype);
+
   AstMin.prototype.visit = function (visitor) {
     visitor.visitMin(this);
   };
+
   function AstVariable(index, min, max) {
     AstNode.call(this, 'var');
     this.index = index;
     this.min = min;
     this.max = max;
   }
+
   AstVariable.prototype = Object.create(AstNode.prototype);
+
   AstVariable.prototype.visit = function (visitor) {
     visitor.visitVariable(this);
   };
+
   function AstVariableDefinition(variable, arg) {
     AstNode.call(this, 'definition');
     this.variable = variable;
     this.arg = arg;
   }
+
   AstVariableDefinition.prototype = Object.create(AstNode.prototype);
+
   AstVariableDefinition.prototype.visit = function (visitor) {
     visitor.visitVariableDefinition(this);
   };
+
   function ExpressionBuilderVisitor() {
     this.parts = [];
   }
+
   ExpressionBuilderVisitor.prototype = {
     visitArgument: function visitArgument(arg) {
       this.parts.push('Math.max(', arg.min, ', Math.min(', arg.max, ', src[srcOffset + ', arg.index, ']))');
@@ -927,18 +1086,23 @@ var PostScriptCompiler = function PostScriptCompilerClosure() {
       return this.parts.join('');
     }
   };
+
   function buildAddOperation(num1, num2) {
     if (num2.type === 'literal' && num2.number === 0) {
       return num1;
     }
+
     if (num1.type === 'literal' && num1.number === 0) {
       return num2;
     }
+
     if (num2.type === 'literal' && num1.type === 'literal') {
       return new AstLiteral(num1.number + num2.number);
     }
+
     return new AstBinaryOperation('+', num1, num2, num1.min + num2.min, num1.max + num2.max);
   }
+
   function buildMulOperation(num1, num2) {
     if (num2.type === 'literal') {
       if (num2.number === 0) {
@@ -949,6 +1113,7 @@ var PostScriptCompiler = function PostScriptCompilerClosure() {
         return new AstLiteral(num1.number * num2.number);
       }
     }
+
     if (num1.type === 'literal') {
       if (num1.number === 0) {
         return new AstLiteral(0);
@@ -956,10 +1121,12 @@ var PostScriptCompiler = function PostScriptCompilerClosure() {
         return num2;
       }
     }
+
     var min = Math.min(num1.min * num2.min, num1.min * num2.max, num1.max * num2.min, num1.max * num2.max);
     var max = Math.max(num1.min * num2.min, num1.min * num2.max, num1.max * num2.min, num1.max * num2.max);
     return new AstBinaryOperation('*', num1, num2, min, max);
   }
+
   function buildSubOperation(num1, num2) {
     if (num2.type === 'literal') {
       if (num2.number === 0) {
@@ -968,20 +1135,26 @@ var PostScriptCompiler = function PostScriptCompilerClosure() {
         return new AstLiteral(num1.number - num2.number);
       }
     }
+
     if (num2.type === 'binary' && num2.op === '-' && num1.type === 'literal' && num1.number === 1 && num2.arg1.type === 'literal' && num2.arg1.number === 1) {
       return num2.arg2;
     }
+
     return new AstBinaryOperation('-', num1, num2, num1.min - num2.max, num1.max - num2.min);
   }
+
   function buildMinOperation(num1, max) {
     if (num1.min >= max) {
       return new AstLiteral(max);
     } else if (num1.max <= max) {
       return num1;
     }
+
     return new AstMin(num1, max);
   }
+
   function PostScriptCompiler() {}
+
   PostScriptCompiler.prototype = {
     compile: function PostScriptCompiler_compile(code, domain, range) {
       var stack = [];
@@ -992,128 +1165,167 @@ var PostScriptCompiler = function PostScriptCompilerClosure() {
       var lastRegister = 0;
       var n, j;
       var num1, num2, ast1, ast2, tmpVar, item;
+
       for (i = 0; i < inputSize; i++) {
         stack.push(new AstArgument(i, domain[i * 2], domain[i * 2 + 1]));
       }
+
       for (i = 0, ii = code.length; i < ii; i++) {
         item = code[i];
+
         if (typeof item === 'number') {
           stack.push(new AstLiteral(item));
           continue;
         }
+
         switch (item) {
           case 'add':
             if (stack.length < 2) {
               return null;
             }
+
             num2 = stack.pop();
             num1 = stack.pop();
             stack.push(buildAddOperation(num1, num2));
             break;
+
           case 'cvr':
             if (stack.length < 1) {
               return null;
             }
+
             break;
+
           case 'mul':
             if (stack.length < 2) {
               return null;
             }
+
             num2 = stack.pop();
             num1 = stack.pop();
             stack.push(buildMulOperation(num1, num2));
             break;
+
           case 'sub':
             if (stack.length < 2) {
               return null;
             }
+
             num2 = stack.pop();
             num1 = stack.pop();
             stack.push(buildSubOperation(num1, num2));
             break;
+
           case 'exch':
             if (stack.length < 2) {
               return null;
             }
+
             ast1 = stack.pop();
             ast2 = stack.pop();
             stack.push(ast1, ast2);
             break;
+
           case 'pop':
             if (stack.length < 1) {
               return null;
             }
+
             stack.pop();
             break;
+
           case 'index':
             if (stack.length < 1) {
               return null;
             }
+
             num1 = stack.pop();
+
             if (num1.type !== 'literal') {
               return null;
             }
+
             n = num1.number;
+
             if (n < 0 || !Number.isInteger(n) || stack.length < n) {
               return null;
             }
+
             ast1 = stack[stack.length - n - 1];
+
             if (ast1.type === 'literal' || ast1.type === 'var') {
               stack.push(ast1);
               break;
             }
+
             tmpVar = new AstVariable(lastRegister++, ast1.min, ast1.max);
             stack[stack.length - n - 1] = tmpVar;
             stack.push(tmpVar);
             instructions.push(new AstVariableDefinition(tmpVar, ast1));
             break;
+
           case 'dup':
             if (stack.length < 1) {
               return null;
             }
+
             if (typeof code[i + 1] === 'number' && code[i + 2] === 'gt' && code[i + 3] === i + 7 && code[i + 4] === 'jz' && code[i + 5] === 'pop' && code[i + 6] === code[i + 1]) {
               num1 = stack.pop();
               stack.push(buildMinOperation(num1, code[i + 1]));
               i += 6;
               break;
             }
+
             ast1 = stack[stack.length - 1];
+
             if (ast1.type === 'literal' || ast1.type === 'var') {
               stack.push(ast1);
               break;
             }
+
             tmpVar = new AstVariable(lastRegister++, ast1.min, ast1.max);
             stack[stack.length - 1] = tmpVar;
             stack.push(tmpVar);
             instructions.push(new AstVariableDefinition(tmpVar, ast1));
             break;
+
           case 'roll':
             if (stack.length < 2) {
               return null;
             }
+
             num2 = stack.pop();
             num1 = stack.pop();
+
             if (num2.type !== 'literal' || num1.type !== 'literal') {
               return null;
             }
+
             j = num2.number;
             n = num1.number;
+
             if (n <= 0 || !Number.isInteger(n) || !Number.isInteger(j) || stack.length < n) {
               return null;
             }
+
             j = (j % n + n) % n;
+
             if (j === 0) {
               break;
             }
+
             Array.prototype.push.apply(stack, stack.splice(stack.length - n, n - j));
             break;
+
           default:
             return null;
         }
       }
+
       if (stack.length !== outputSize) {
         return null;
       }
+
       var result = [];
       instructions.forEach(function (instruction) {
         var statementBuilder = new ExpressionBuilderVisitor();
@@ -1126,14 +1338,17 @@ var PostScriptCompiler = function PostScriptCompilerClosure() {
         var min = range[i * 2],
             max = range[i * 2 + 1];
         var out = [statementBuilder.toString()];
+
         if (min > expr.min) {
           out.unshift('Math.max(', min, ', ');
           out.push(')');
         }
+
         if (max < expr.max) {
           out.unshift('Math.min(', max, ', ');
           out.push(')');
         }
+
         out.unshift('dest[destOffset + ', i, '] = ');
         out.push(';');
         result.push(out.join(''));
@@ -1143,7 +1358,5 @@ var PostScriptCompiler = function PostScriptCompilerClosure() {
   };
   return PostScriptCompiler;
 }();
-exports.isPDFFunction = isPDFFunction;
-exports.PDFFunctionFactory = PDFFunctionFactory;
-exports.PostScriptEvaluator = PostScriptEvaluator;
+
 exports.PostScriptCompiler = PostScriptCompiler;