Merge pull request #8968 from Snuffleupagus/PDFFunctionFactory-2

Split the existing `PDFFunction` in two classes, a private `PDFFunction` and a public `PDFFunctionFactory``, and utilize the latter in `PDFDocument` to allow various code to access the methods of `PDFFunction`

src/core/colorspace.js

@@ -15,7 +15,6 @@
 
 import { FormatError, info, isString, shadow, warn } from '../shared/util';
 import { isDict, isName, isStream } from './primitives';
-import { PDFFunction } from './function';
 
 var ColorSpace = (function ColorSpaceClosure() {
   /**
@@ -200,12 +199,12 @@ var ColorSpace = (function ColorSpaceClosure() {
     usesZeroToOneRange: true,
   };
 
-  ColorSpace.parse = function ColorSpace_parse(cs, xref, res) {
-    let IR = ColorSpace.parseToIR(cs, xref, res);
-    return ColorSpace.fromIR(IR);
+  ColorSpace.parse = function(cs, xref, res, pdfFunctionFactory) {
+    let IR = ColorSpace.parseToIR(cs, xref, res, pdfFunctionFactory);
+    return ColorSpace.fromIR(IR, pdfFunctionFactory);
   };
 
-  ColorSpace.fromIR = function ColorSpace_fromIR(IR) {
+  ColorSpace.fromIR = function(IR, pdfFunctionFactory) {
     var name = Array.isArray(IR) ? IR[0] : IR;
     var whitePoint, blackPoint, gamma;
 
@@ -230,21 +229,23 @@ var ColorSpace = (function ColorSpaceClosure() {
       case 'PatternCS':
         var basePatternCS = IR[1];
         if (basePatternCS) {
-          basePatternCS = ColorSpace.fromIR(basePatternCS);
+          basePatternCS = ColorSpace.fromIR(basePatternCS, pdfFunctionFactory);
         }
         return new PatternCS(basePatternCS);
       case 'IndexedCS':
         var baseIndexedCS = IR[1];
         var hiVal = IR[2];
         var lookup = IR[3];
-        return new IndexedCS(ColorSpace.fromIR(baseIndexedCS), hiVal, lookup);
+        return new IndexedCS(ColorSpace.fromIR(baseIndexedCS,
+                                               pdfFunctionFactory),
+                             hiVal, lookup);
       case 'AlternateCS':
         var numComps = IR[1];
         var alt = IR[2];
         var tintFnIR = IR[3];
-
-        return new AlternateCS(numComps, ColorSpace.fromIR(alt),
-                               PDFFunction.fromIR(tintFnIR));
+        return new AlternateCS(numComps, ColorSpace.fromIR(alt,
+                                                           pdfFunctionFactory),
+                               pdfFunctionFactory.createFromIR(tintFnIR));
       case 'LabCS':
         whitePoint = IR[1];
         blackPoint = IR[2];
@@ -255,7 +256,7 @@ var ColorSpace = (function ColorSpaceClosure() {
     }
   };
 
-  ColorSpace.parseToIR = function ColorSpace_parseToIR(cs, xref, res) {
+  ColorSpace.parseToIR = function(cs, xref, res, pdfFunctionFactory) {
     if (isName(cs)) {
       var colorSpaces = res.get('ColorSpace');
       if (isDict(colorSpaces)) {
@@ -317,10 +318,11 @@ var ColorSpace = (function ColorSpaceClosure() {
           numComps = dict.get('N');
           alt = dict.get('Alternate');
           if (alt) {
-            var altIR = ColorSpace.parseToIR(alt, xref, res);
+            var altIR = ColorSpace.parseToIR(alt, xref, res,
+                                             pdfFunctionFactory);
             // Parse the /Alternate CS to ensure that the number of components
             // are correct, and also (indirectly) that it is not a PatternCS.
-            var altCS = ColorSpace.fromIR(altIR);
+            var altCS = ColorSpace.fromIR(altIR, pdfFunctionFactory);
             if (altCS.numComps === numComps) {
               return altIR;
             }
@@ -337,12 +339,14 @@ var ColorSpace = (function ColorSpaceClosure() {
         case 'Pattern':
           var basePatternCS = cs[1] || null;
           if (basePatternCS) {
-            basePatternCS = ColorSpace.parseToIR(basePatternCS, xref, res);
+            basePatternCS = ColorSpace.parseToIR(basePatternCS, xref, res,
+                                                 pdfFunctionFactory);
           }
           return ['PatternCS', basePatternCS];
         case 'Indexed':
         case 'I':
-          var baseIndexedCS = ColorSpace.parseToIR(cs[1], xref, res);
+          var baseIndexedCS = ColorSpace.parseToIR(cs[1], xref, res,
+                                                   pdfFunctionFactory);
           var hiVal = xref.fetchIfRef(cs[2]) + 1;
           var lookup = xref.fetchIfRef(cs[3]);
           if (isStream(lookup)) {
@@ -353,8 +357,8 @@ var ColorSpace = (function ColorSpaceClosure() {
         case 'DeviceN':
           var name = xref.fetchIfRef(cs[1]);
           numComps = Array.isArray(name) ? name.length : 1;
-          alt = ColorSpace.parseToIR(cs[2], xref, res);
-          var tintFnIR = PDFFunction.getIR(xref, xref.fetchIfRef(cs[3]));
+          alt = ColorSpace.parseToIR(cs[2], xref, res, pdfFunctionFactory);
+          let tintFnIR = pdfFunctionFactory.createIR(xref.fetchIfRef(cs[3]));
           return ['AlternateCS', numComps, alt, tintFnIR];
         case 'Lab':
           params = xref.fetchIfRef(cs[1]);

src/core/document.js

@@ -24,7 +24,7 @@ import { OperatorList, PartialEvaluator } from './evaluator';
 import { AnnotationFactory } from './annotation';
 import { calculateMD5 } from './crypto';
 import { Linearization } from './parser';
-import { PDFFunction } from './function';
+import { PDFFunctionFactory } from './function';
 
 var Page = (function PageClosure() {
 
@@ -36,8 +36,8 @@ var Page = (function PageClosure() {
            (intent === 'print' && annotation.printable);
   }
 
-  function Page(pdfManager, xref, pageIndex, pageDict, ref, fontCache,
-                builtInCMapCache) {
+  function Page({ pdfManager, xref, pageIndex, pageDict, ref, fontCache,
+                  builtInCMapCache, pdfFunctionFactory, }) {
     this.pdfManager = pdfManager;
     this.pageIndex = pageIndex;
     this.pageDict = pageDict;
@@ -45,6 +45,7 @@ var Page = (function PageClosure() {
     this.ref = ref;
     this.fontCache = fontCache;
     this.builtInCMapCache = builtInCMapCache;
+    this.pdfFunctionFactory = pdfFunctionFactory;
     this.evaluatorOptions = pdfManager.evaluatorOptions;
     this.resourcesPromise = null;
 
@@ -215,6 +216,7 @@ var Page = (function PageClosure() {
         fontCache: this.fontCache,
         builtInCMapCache: this.builtInCMapCache,
         options: this.evaluatorOptions,
+        pdfFunctionFactory: this.pdfFunctionFactory,
       });
 
       var dataPromises = Promise.all([contentStreamPromise, resourcesPromise]);
@@ -290,6 +292,7 @@ var Page = (function PageClosure() {
           fontCache: this.fontCache,
           builtInCMapCache: this.builtInCMapCache,
           options: this.evaluatorOptions,
+          pdfFunctionFactory: this.pdfFunctionFactory,
         });
 
         return partialEvaluator.getTextContent({
@@ -361,6 +364,12 @@ var PDFDocument = (function PDFDocumentClosure() {
     this.pdfManager = pdfManager;
     this.stream = stream;
     this.xref = new XRef(stream, pdfManager);
+
+    let evaluatorOptions = pdfManager.evaluatorOptions;
+    this.pdfFunctionFactory = new PDFFunctionFactory({
+      xref: this.xref,
+      isEvalSupported: evaluatorOptions.isEvalSupported,
+    });
   }
 
   function find(stream, needle, limit, backwards) {
@@ -528,14 +537,19 @@ var PDFDocument = (function PDFDocumentClosure() {
       this.xref.parse(recoveryMode);
       var pageFactory = {
         createPage: (pageIndex, dict, ref, fontCache, builtInCMapCache) => {
-          return new Page(this.pdfManager, this.xref, pageIndex, dict, ref,
-                          fontCache, builtInCMapCache);
+          return new Page({
+            pdfManager: this.pdfManager,
+            xref: this.xref,
+            pageIndex,
+            pageDict: dict,
+            ref,
+            fontCache,
+            builtInCMapCache,
+            pdfFunctionFactory: this.pdfFunctionFactory,
+          });
         },
       };
       this.catalog = new Catalog(this.pdfManager, this.xref, pageFactory);
-
-      let evaluatorOptions = this.pdfManager.evaluatorOptions;
-      PDFFunction.setIsEvalSupported(evaluatorOptions.isEvalSupported);
     },
     get numPages() {
       var linearization = this.linearization;

src/core/evaluator.js

@@ -38,12 +38,12 @@ import {
   getSerifFonts, getStdFontMap, getSymbolsFonts
 } from './standard_fonts';
 import { getTilingPatternIR, Pattern } from './pattern';
-import { isPDFFunction, PDFFunction } from './function';
 import { Lexer, Parser } from './parser';
 import { bidi } from './bidi';
 import { ColorSpace } from './colorspace';
 import { getGlyphsUnicode } from './glyphlist';
 import { getMetrics } from './metrics';
+import { isPDFFunction } from './function';
 import { MurmurHash3_64 } from './murmurhash3';
 import { PDFImage } from './image';
 
@@ -57,22 +57,27 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
     isEvalSupported: true,
   };
 
-  function NativeImageDecoder(xref, resources, handler, forceDataSchema) {
+  function NativeImageDecoder({ xref, resources, handler,
+                                forceDataSchema = false,
+                                pdfFunctionFactory, }) {
     this.xref = xref;
     this.resources = resources;
     this.handler = handler;
     this.forceDataSchema = forceDataSchema;
+    this.pdfFunctionFactory = pdfFunctionFactory;
   }
   NativeImageDecoder.prototype = {
     canDecode(image) {
       return image instanceof JpegStream &&
-             NativeImageDecoder.isDecodable(image, this.xref, this.resources);
+             NativeImageDecoder.isDecodable(image, this.xref, this.resources,
+                                            this.pdfFunctionFactory);
     },
     decode(image) {
       // For natively supported JPEGs send them to the main thread for decoding.
       var dict = image.dict;
       var colorSpace = dict.get('ColorSpace', 'CS');
-      colorSpace = ColorSpace.parse(colorSpace, this.xref, this.resources);
+      colorSpace = ColorSpace.parse(colorSpace, this.xref, this.resources,
+                                    this.pdfFunctionFactory);
       var numComps = colorSpace.numComps;
       var decodePromise = this.handler.sendWithPromise('JpegDecode',
         [image.getIR(this.forceDataSchema), numComps]);
@@ -86,32 +91,35 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
    * Checks if the image can be decoded and displayed by the browser without any
    * further processing such as color space conversions.
    */
-  NativeImageDecoder.isSupported =
-      function NativeImageDecoder_isSupported(image, xref, res) {
+  NativeImageDecoder.isSupported = function(image, xref, res,
+                                            pdfFunctionFactory) {
     var dict = image.dict;
     if (dict.has('DecodeParms') || dict.has('DP')) {
       return false;
     }
-    var cs = ColorSpace.parse(dict.get('ColorSpace', 'CS'), xref, res);
+    var cs = ColorSpace.parse(dict.get('ColorSpace', 'CS'), xref, res,
+                              pdfFunctionFactory);
     return (cs.name === 'DeviceGray' || cs.name === 'DeviceRGB') &&
            cs.isDefaultDecode(dict.getArray('Decode', 'D'));
   };
   /**
    * Checks if the image can be decoded by the browser.
    */
-  NativeImageDecoder.isDecodable =
-      function NativeImageDecoder_isDecodable(image, xref, res) {
+  NativeImageDecoder.isDecodable = function(image, xref, res,
+                                            pdfFunctionFactory) {
     var dict = image.dict;
     if (dict.has('DecodeParms') || dict.has('DP')) {
       return false;
     }
-    var cs = ColorSpace.parse(dict.get('ColorSpace', 'CS'), xref, res);
+    var cs = ColorSpace.parse(dict.get('ColorSpace', 'CS'), xref, res,
+                              pdfFunctionFactory);
     return (cs.numComps === 1 || cs.numComps === 3) &&
            cs.isDefaultDecode(dict.getArray('Decode', 'D'));
   };
 
   function PartialEvaluator({ pdfManager, xref, handler, pageIndex, idFactory,
-                              fontCache, builtInCMapCache, options = null, }) {
+                              fontCache, builtInCMapCache, options = null,
+                              pdfFunctionFactory, }) {
     this.pdfManager = pdfManager;
     this.xref = xref;
     this.handler = handler;
@@ -120,6 +128,7 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
     this.fontCache = fontCache;
     this.builtInCMapCache = builtInCMapCache;
     this.options = options || DefaultPartialEvaluatorOptions;
+    this.pdfFunctionFactory = pdfFunctionFactory;
 
     this.fetchBuiltInCMap = (name) => {
       var cachedCMap = this.builtInCMapCache[name];
@@ -303,12 +312,14 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
         };
 
         var groupSubtype = group.get('S');
-        var colorSpace;
+        var colorSpace = null;
         if (isName(groupSubtype, 'Transparency')) {
           groupOptions.isolated = (group.get('I') || false);
           groupOptions.knockout = (group.get('K') || false);
-          colorSpace = (group.has('CS') ?
-            ColorSpace.parse(group.get('CS'), this.xref, resources) : null);
+          if (group.has('CS')) {
+            colorSpace = ColorSpace.parse(group.get('CS'), this.xref, resources,
+                                          this.pdfFunctionFactory);
+          }
         }
 
         if (smask && smask.backdrop) {
@@ -368,11 +379,14 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
         var bitStrideLength = (width + 7) >> 3;
         var imgArray = image.getBytes(bitStrideLength * height);
         var decode = dict.getArray('Decode', 'D');
-        var inverseDecode = (!!decode && decode[0] > 0);
 
-        imgData = PDFImage.createMask(imgArray, width, height,
-                                      image instanceof DecodeStream,
-                                      inverseDecode);
+        imgData = PDFImage.createMask({
+          imgArray,
+          width,
+          height,
+          imageIsFromDecodeStream: image instanceof DecodeStream,
+          inverseDecode: (!!decode && decode[0] > 0),
+        });
         imgData.cached = true;
         args = [imgData];
         operatorList.addOp(OPS.paintImageMaskXObject, args);
@@ -392,8 +406,12 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
       // Inlining small images into the queue as RGB data
       if (inline && !softMask && !mask && !(image instanceof JpegStream) &&
           (w + h) < SMALL_IMAGE_DIMENSIONS) {
-        var imageObj = new PDFImage(this.xref, resources, image,
-                                    inline, null, null);
+        let imageObj = new PDFImage({
+          xref: this.xref,
+          res: resources,
+          image,
+          pdfFunctionFactory: this.pdfFunctionFactory,
+        });
         // We force the use of RGBA_32BPP images here, because we can't handle
         // any other kind.
         imgData = imageObj.createImageData(/* forceRGBA = */ true);
@@ -410,7 +428,8 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
 
       if (nativeImageDecoderSupport !== NativeImageDecoding.NONE &&
           !softMask && !mask && image instanceof JpegStream &&
-          NativeImageDecoder.isSupported(image, this.xref, resources)) {
+          NativeImageDecoder.isSupported(image, this.xref, resources,
+                                         this.pdfFunctionFactory)) {
         // These JPEGs don't need any more processing so we can just send it.
         operatorList.addOp(OPS.paintJpegXObject, args);
         this.handler.send('obj', [objId, this.pageIndex, 'JpegStream',
@@ -429,12 +448,23 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
       if (nativeImageDecoderSupport === NativeImageDecoding.DECODE &&
           (image instanceof JpegStream || mask instanceof JpegStream ||
            softMask instanceof JpegStream)) {
-        nativeImageDecoder = new NativeImageDecoder(this.xref, resources,
-          this.handler, this.options.forceDataSchema);
+        nativeImageDecoder = new NativeImageDecoder({
+          xref: this.xref,
+          resources,
+          handler: this.handler,
+          forceDataSchema: this.options.forceDataSchema,
+          pdfFunctionFactory: this.pdfFunctionFactory,
+        });
       }
 
-      PDFImage.buildImage(this.handler, this.xref, resources, image, inline,
-                          nativeImageDecoder).then((imageObj) => {
+      PDFImage.buildImage({
+        handler: this.handler,
+        xref: this.xref,
+        res: resources,
+        image,
+        nativeDecoder: nativeImageDecoder,
+        pdfFunctionFactory: this.pdfFunctionFactory,
+      }).then((imageObj) => {
         var imgData = imageObj.createImageData(/* forceRGBA = */ false);
         this.handler.send('obj', [objId, this.pageIndex, 'Image', imgData],
           [imgData.data.buffer]);
@@ -465,7 +495,7 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
       // we will build a map of integer values in range 0..255 to be fast.
       var transferObj = smask.get('TR');
       if (isPDFFunction(transferObj)) {
-        var transferFn = PDFFunction.parse(this.xref, transferObj);
+        let transferFn = this.pdfFunctionFactory.create(transferObj);
         var transferMap = new Uint8Array(256);
         var tmp = new Float32Array(1);
         for (var i = 0; i < 256; i++) {
@@ -851,7 +881,7 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
           var shading = dict.get('Shading');
           var matrix = dict.getArray('Matrix');
           pattern = Pattern.parseShading(shading, matrix, this.xref, resources,
-                                         this.handler);
+                                         this.handler, this.pdfFunctionFactory);
           operatorList.addOp(fn, pattern.getIR());
           return Promise.resolve();
         }
@@ -1026,11 +1056,13 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
 
             case OPS.setFillColorSpace:
               stateManager.state.fillColorSpace =
-                ColorSpace.parse(args[0], xref, resources);
+                ColorSpace.parse(args[0], xref, resources,
+                                 self.pdfFunctionFactory);
               continue;
             case OPS.setStrokeColorSpace:
               stateManager.state.strokeColorSpace =
-                ColorSpace.parse(args[0], xref, resources);
+                ColorSpace.parse(args[0], xref, resources,
+                                 self.pdfFunctionFactory);
               continue;
             case OPS.setFillColor:
               cs = stateManager.state.fillColorSpace;
@@ -1103,7 +1135,7 @@ var PartialEvaluator = (function PartialEvaluatorClosure() {
               }
 
               var shadingFill = Pattern.parseShading(shading, null, xref,
-                resources, self.handler);
+                resources, self.handler, self.pdfFunctionFactory);
               var patternIR = shadingFill.getIR();
               args = [patternIR];
               fn = OPS.shadingFill;

src/core/function.js

@@ -25,21 +25,53 @@ let IsEvalSupportedCached = {
   },
 };
 
-var PDFFunction = (function PDFFunctionClosure() {
-  var CONSTRUCT_SAMPLED = 0;
-  var CONSTRUCT_INTERPOLATED = 2;
-  var CONSTRUCT_STICHED = 3;
-  var CONSTRUCT_POSTSCRIPT = 4;
+class PDFFunctionFactory {
+  constructor({ xref, isEvalSupported = true, }) {
+    this.xref = xref;
+    this.isEvalSupported = isEvalSupported !== false;
+  }
 
-  let isEvalSupported = true;
+  create(fn) {
+    return PDFFunction.parse({
+      xref: this.xref,
+      isEvalSupported: this.isEvalSupported,
+      fn,
+    });
+  }
 
-  return {
-    setIsEvalSupported(support = true) {
-      isEvalSupported = support !== false;
-    },
+  createFromArray(fnObj) {
+    return PDFFunction.parseArray({
+      xref: this.xref,
+      isEvalSupported: this.isEvalSupported,
+      fnObj,
+    });
+  }
+
+  createFromIR(IR) {
+    return PDFFunction.fromIR({
+      xref: this.xref,
+      isEvalSupported: this.isEvalSupported,
+      IR,
+    });
+  }
+
+  createIR(fn) {
+    return PDFFunction.getIR({
+      xref: this.xref,
+      isEvalSupported: this.isEvalSupported,
+      fn,
+    });
+  }
+}
 
-    getSampleArray: function PDFFunction_getSampleArray(size, outputSize, bps,
-                                                       str) {
+var PDFFunction = (function PDFFunctionClosure() {
+  const CONSTRUCT_SAMPLED = 0;
+  const CONSTRUCT_INTERPOLATED = 2;
+  const CONSTRUCT_STICHED = 3;
+  const CONSTRUCT_POSTSCRIPT = 4;
+
+  return {
+    getSampleArray(size, outputSize, bps, stream) {
       var i, ii;
       var length = 1;
       for (i = 0, ii = size.length; i < ii; i++) {
@@ -53,7 +85,7 @@ var PDFFunction = (function PDFFunctionClosure() {
       // 32 is a valid bps so shifting won't work
       var sampleMul = 1.0 / (Math.pow(2.0, bps) - 1);
 
-      var strBytes = str.getBytes((length * bps + 7) / 8);
+      var strBytes = stream.getBytes((length * bps + 7) / 8);
       var strIdx = 0;
       for (i = 0; i < length; i++) {
         while (codeSize < bps) {
@@ -68,7 +100,7 @@ var PDFFunction = (function PDFFunctionClosure() {
       return array;
     },
 
-    getIR: function PDFFunction_getIR(xref, fn) {
+    getIR({ xref, isEvalSupported, fn, }) {
       var dict = fn.dict;
       if (!dict) {
         dict = fn;
@@ -86,48 +118,49 @@ var PDFFunction = (function PDFFunctionClosure() {
         throw new FormatError('Unknown type of function');
       }
 
-      return typeFn.call(this, fn, dict, xref);
+      return typeFn.call(this, { xref, isEvalSupported, fn, dict, });
     },
 
-    fromIR: function PDFFunction_fromIR(IR) {
+    fromIR({ xref, isEvalSupported, IR, }) {
       var type = IR[0];
       switch (type) {
         case CONSTRUCT_SAMPLED:
-          return this.constructSampledFromIR(IR);
+          return this.constructSampledFromIR({ xref, isEvalSupported, IR, });
         case CONSTRUCT_INTERPOLATED:
-          return this.constructInterpolatedFromIR(IR);
+          return this.constructInterpolatedFromIR({ xref, isEvalSupported,
+                                                    IR, });
         case CONSTRUCT_STICHED:
-          return this.constructStichedFromIR(IR);
+          return this.constructStichedFromIR({ xref, isEvalSupported, IR, });
         // case CONSTRUCT_POSTSCRIPT:
         default:
-          return this.constructPostScriptFromIR(IR);
+          return this.constructPostScriptFromIR({ xref, isEvalSupported, IR, });
       }
     },
 
-    parse: function PDFFunction_parse(xref, fn) {
-      var IR = this.getIR(xref, fn);
-      return this.fromIR(IR);
+    parse({ xref, isEvalSupported, fn, }) {
+      let IR = this.getIR({ xref, isEvalSupported, fn, });
+      return this.fromIR({ xref, isEvalSupported, IR, });
     },
 
-    parseArray: function PDFFunction_parseArray(xref, fnObj) {
+    parseArray({ xref, isEvalSupported, fnObj, }) {
       if (!Array.isArray(fnObj)) {
         // not an array -- parsing as regular function
-        return this.parse(xref, fnObj);
+        return this.parse({ xref, isEvalSupported, fn: fnObj, });
       }
 
       var fnArray = [];
       for (var j = 0, jj = fnObj.length; j < jj; j++) {
-        var obj = xref.fetchIfRef(fnObj[j]);
-        fnArray.push(PDFFunction.parse(xref, obj));
+        fnArray.push(this.parse({ xref, isEvalSupported,
+                                  fn: xref.fetchIfRef(fnObj[j]), }));
       }
-      return function (src, srcOffset, dest, destOffset) {
+      return function(src, srcOffset, dest, destOffset) {
         for (var i = 0, ii = fnArray.length; i < ii; i++) {
           fnArray[i](src, srcOffset, dest, destOffset + i);
         }
       };
     },
 
-    constructSampled: function PDFFunction_constructSampled(str, dict) {
+    constructSampled({ xref, isEvalSupported, fn, dict, }) {
       function toMultiArray(arr) {
         var inputLength = arr.length;
         var out = [];
@@ -177,7 +210,7 @@ var PDFFunction = (function PDFFunctionClosure() {
         decode = toMultiArray(decode);
       }
 
-      var samples = this.getSampleArray(size, outputSize, bps, str);
+      var samples = this.getSampleArray(size, outputSize, bps, fn);
 
       return [
         CONSTRUCT_SAMPLED, inputSize, domain, encode, decode, samples, size,
@@ -185,7 +218,7 @@ var PDFFunction = (function PDFFunctionClosure() {
       ];
     },
 
-    constructSampledFromIR: function PDFFunction_constructSampledFromIR(IR) {
+    constructSampledFromIR({ xref, isEvalSupported, IR, }) {
       // See chapter 3, page 109 of the PDF reference
       function interpolate(x, xmin, xmax, ymin, ymax) {
         return ymin + ((x - xmin) * ((ymax - ymin) / (xmax - xmin)));
@@ -270,8 +303,7 @@ var PDFFunction = (function PDFFunctionClosure() {
       };
     },
 
-    constructInterpolated: function PDFFunction_constructInterpolated(str,
-                                                                      dict) {
+    constructInterpolated({ xref, isEvalSupported, fn, dict, }) {
       var c0 = dict.getArray('C0') || [0];
       var c1 = dict.getArray('C1') || [1];
       var n = dict.get('N');
@@ -290,8 +322,7 @@ var PDFFunction = (function PDFFunctionClosure() {
       return [CONSTRUCT_INTERPOLATED, c0, diff, n];
     },
 
-    constructInterpolatedFromIR:
-      function PDFFunction_constructInterpolatedFromIR(IR) {
+    constructInterpolatedFromIR({ xref, isEvalSupported, IR, }) {
       var c0 = IR[1];
       var diff = IR[2];
       var n = IR[3];
@@ -308,7 +339,7 @@ var PDFFunction = (function PDFFunctionClosure() {
       };
     },
 
-    constructStiched: function PDFFunction_constructStiched(fn, dict, xref) {
+    constructStiched({ xref, isEvalSupported, fn, dict, }) {
       var domain = dict.getArray('Domain');
 
       if (!domain) {
@@ -323,7 +354,8 @@ var PDFFunction = (function PDFFunctionClosure() {
       var fnRefs = dict.get('Functions');
       var fns = [];
       for (var i = 0, ii = fnRefs.length; i < ii; ++i) {
-        fns.push(PDFFunction.getIR(xref, xref.fetchIfRef(fnRefs[i])));
+        fns.push(this.getIR({ xref, isEvalSupported,
+                              fn: xref.fetchIfRef(fnRefs[i]), }));
       }
 
       var bounds = dict.getArray('Bounds');
@@ -332,7 +364,7 @@ var PDFFunction = (function PDFFunctionClosure() {
       return [CONSTRUCT_STICHED, domain, bounds, encode, fns];
     },
 
-    constructStichedFromIR: function PDFFunction_constructStichedFromIR(IR) {
+    constructStichedFromIR({ xref, isEvalSupported, IR, }) {
       var domain = IR[1];
       var bounds = IR[2];
       var encode = IR[3];
@@ -341,7 +373,7 @@ var PDFFunction = (function PDFFunctionClosure() {
       var tmpBuf = new Float32Array(1);
 
       for (var i = 0, ii = fnsIR.length; i < ii; i++) {
-        fns.push(PDFFunction.fromIR(fnsIR[i]));
+        fns.push(this.fromIR({ xref, isEvalSupported, IR: fnsIR[i], }));
       }
 
       return function constructStichedFromIRResult(src, srcOffset,
@@ -387,8 +419,7 @@ var PDFFunction = (function PDFFunctionClosure() {
       };
     },
 
-    constructPostScript: function PDFFunction_constructPostScript(fn, dict,
-                                                                  xref) {
+    constructPostScript({ xref, isEvalSupported, fn, dict, }) {
       var domain = dict.getArray('Domain');
       var range = dict.getArray('Range');
 
@@ -407,8 +438,7 @@ var PDFFunction = (function PDFFunctionClosure() {
       return [CONSTRUCT_POSTSCRIPT, domain, range, code];
     },
 
-    constructPostScriptFromIR: function PDFFunction_constructPostScriptFromIR(
-                                          IR) {
+    constructPostScriptFromIR({ xref, isEvalSupported, IR, }) {
       var domain = IR[1];
       var range = IR[2];
       var code = IR[3];
@@ -1151,7 +1181,7 @@ var PostScriptCompiler = (function PostScriptCompilerClosure() {
 
 export {
   isPDFFunction,
-  PDFFunction,
+  PDFFunctionFactory,
   PostScriptEvaluator,
   PostScriptCompiler,
 };

src/core/image.js

@@ -74,7 +74,8 @@ var PDFImage = (function PDFImageClosure() {
     return dest;
   }
 
-  function PDFImage(xref, res, image, inline, smask, mask, isMask) {
+  function PDFImage({ xref, res, image, smask = null, mask = null,
+                      isMask = false, pdfFunctionFactory, }) {
     this.image = image;
     var dict = image.dict;
     if (dict.has('Filter')) {
@@ -137,7 +138,8 @@ var PDFImage = (function PDFImageClosure() {
                             'color components not supported.');
         }
       }
-      this.colorSpace = ColorSpace.parse(colorSpace, xref, res);
+      this.colorSpace = ColorSpace.parse(colorSpace, xref, res,
+                                         pdfFunctionFactory);
       this.numComps = this.colorSpace.numComps;
     }
 
@@ -160,14 +162,25 @@ var PDFImage = (function PDFImageClosure() {
     }
 
     if (smask) {
-      this.smask = new PDFImage(xref, res, smask, false);
+      this.smask = new PDFImage({
+        xref,
+        res,
+        image: smask,
+        pdfFunctionFactory,
+      });
     } else if (mask) {
       if (isStream(mask)) {
         var maskDict = mask.dict, imageMask = maskDict.get('ImageMask', 'IM');
         if (!imageMask) {
           warn('Ignoring /Mask in image without /ImageMask.');
         } else {
-          this.mask = new PDFImage(xref, res, mask, false, null, null, true);
+          this.mask = new PDFImage({
+            xref,
+            res,
+            image: mask,
+            isMask: true,
+            pdfFunctionFactory,
+          });
         }
       } else {
         // Color key mask (just an array).
@@ -179,9 +192,9 @@ var PDFImage = (function PDFImageClosure() {
    * Handles processing of image data and returns the Promise that is resolved
    * with a PDFImage when the image is ready to be used.
    */
-  PDFImage.buildImage = function PDFImage_buildImage(handler, xref,
-                                                     res, image, inline,
-                                                     nativeDecoder) {
+  PDFImage.buildImage = function({ handler, xref, res, image,
+                                   nativeDecoder = null,
+                                   pdfFunctionFactory, }) {
     var imagePromise = handleImageData(image, nativeDecoder);
     var smaskPromise;
     var maskPromise;
@@ -208,18 +221,20 @@ var PDFImage = (function PDFImageClosure() {
       }
     }
     return Promise.all([imagePromise, smaskPromise, maskPromise]).then(
-      function(results) {
-        var imageData = results[0];
-        var smaskData = results[1];
-        var maskData = results[2];
-        return new PDFImage(xref, res, imageData, inline, smaskData, maskData);
+      function([imageData, smaskData, maskData]) {
+        return new PDFImage({
+          xref,
+          res,
+          image: imageData,
+          smask: smaskData,
+          mask: maskData,
+          pdfFunctionFactory,
+        });
       });
   };
 
-  PDFImage.createMask =
-      function PDFImage_createMask(imgArray, width, height,
-                                   imageIsFromDecodeStream, inverseDecode) {
-
+  PDFImage.createMask = function({ imgArray, width, height,
+                                   imageIsFromDecodeStream, inverseDecode, }) {
     // |imgArray| might not contain full data for every pixel of the mask, so
     // we need to distinguish between |computedLength| and |actualLength|.
     // In particular, if inverseDecode is true, then the array we return must
@@ -271,7 +286,7 @@ var PDFImage = (function PDFImageClosure() {
                       this.mask && this.mask.height || 0);
     },
 
-    decodeBuffer: function PDFImage_decodeBuffer(buffer) {
+    decodeBuffer(buffer) {
       var bpc = this.bpc;
       var numComps = this.numComps;
 
@@ -297,7 +312,7 @@ var PDFImage = (function PDFImageClosure() {
       }
     },
 
-    getComponents: function PDFImage_getComponents(buffer) {
+    getComponents(buffer) {
       var bpc = this.bpc;
 
       // This image doesn't require any extra work.
@@ -374,8 +389,7 @@ var PDFImage = (function PDFImageClosure() {
       return output;
     },
 
-    fillOpacity: function PDFImage_fillOpacity(rgbaBuf, width, height,
-                                               actualHeight, image) {
+    fillOpacity(rgbaBuf, width, height, actualHeight, image) {
       var smask = this.smask;
       var mask = this.mask;
       var alphaBuf, sw, sh, i, ii, j;
@@ -441,7 +455,7 @@ var PDFImage = (function PDFImageClosure() {
       }
     },
 
-    undoPreblend: function PDFImage_undoPreblend(buffer, width, height) {
+    undoPreblend(buffer, width, height) {
       var matte = this.smask && this.smask.matte;
       if (!matte) {
         return;
@@ -472,7 +486,7 @@ var PDFImage = (function PDFImageClosure() {
       }
     },
 
-    createImageData: function PDFImage_createImageData(forceRGBA) {
+    createImageData(forceRGBA = false) {
       var drawWidth = this.drawWidth;
       var drawHeight = this.drawHeight;
       var imgData = { // other fields are filled in below
@@ -581,7 +595,7 @@ var PDFImage = (function PDFImageClosure() {
       return imgData;
     },
 
-    fillGrayBuffer: function PDFImage_fillGrayBuffer(buffer) {
+    fillGrayBuffer(buffer) {
       var numComps = this.numComps;
       if (numComps !== 1) {
         throw new FormatError(
@@ -627,9 +641,7 @@ var PDFImage = (function PDFImageClosure() {
       }
     },
 
-    getImageBytes: function PDFImage_getImageBytes(length,
-                                                   drawWidth, drawHeight,
-                                                   forceRGB) {
+    getImageBytes(length, drawWidth, drawHeight, forceRGB = false) {
       this.image.reset();
       this.image.drawWidth = drawWidth || this.width;
       this.image.drawHeight = drawHeight || this.height;

src/core/pattern.js

@@ -20,7 +20,6 @@ import {
 } from '../shared/util';
 import { ColorSpace } from './colorspace';
 import { isStream } from './primitives';
-import { PDFFunction } from './function';
 
 var ShadingType = {
   FUNCTION_BASED: 1,
@@ -46,9 +45,8 @@ var Pattern = (function PatternClosure() {
     },
   };
 
-  Pattern.parseShading = function Pattern_parseShading(shading, matrix, xref,
-                                                       res, handler) {
-
+  Pattern.parseShading = function(shading, matrix, xref, res, handler,
+                                  pdfFunctionFactory) {
     var dict = isStream(shading) ? shading.dict : shading;
     var type = dict.get('ShadingType');
 
@@ -57,12 +55,14 @@ var Pattern = (function PatternClosure() {
         case ShadingType.AXIAL:
         case ShadingType.RADIAL:
           // Both radial and axial shadings are handled by RadialAxial shading.
-          return new Shadings.RadialAxial(dict, matrix, xref, res);
+          return new Shadings.RadialAxial(dict, matrix, xref, res,
+                                          pdfFunctionFactory);
         case ShadingType.FREE_FORM_MESH:
         case ShadingType.LATTICE_FORM_MESH:
         case ShadingType.COONS_PATCH_MESH:
         case ShadingType.TENSOR_PATCH_MESH:
-          return new Shadings.Mesh(shading, matrix, xref, res);
+          return new Shadings.Mesh(shading, matrix, xref, res,
+                                   pdfFunctionFactory);
         default:
           throw new FormatError('Unsupported ShadingType: ' + type);
       }
@@ -88,13 +88,13 @@ Shadings.SMALL_NUMBER = 1e-6;
 // Radial and axial shading have very similar implementations
 // If needed, the implementations can be broken into two classes
 Shadings.RadialAxial = (function RadialAxialClosure() {
-  function RadialAxial(dict, matrix, xref, res) {
+  function RadialAxial(dict, matrix, xref, res, pdfFunctionFactory) {
     this.matrix = matrix;
     this.coordsArr = dict.getArray('Coords');
     this.shadingType = dict.get('ShadingType');
     this.type = 'Pattern';
     var cs = dict.get('ColorSpace', 'CS');
-    cs = ColorSpace.parse(cs, xref, res);
+    cs = ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
     this.cs = cs;
 
     var t0 = 0.0, t1 = 1.0;
@@ -132,7 +132,7 @@ Shadings.RadialAxial = (function RadialAxialClosure() {
     this.extendEnd = extendEnd;
 
     var fnObj = dict.get('Function');
-    var fn = PDFFunction.parseArray(xref, fnObj);
+    var fn = pdfFunctionFactory.createFromArray(fnObj);
 
     // 10 samples seems good enough for now, but probably won't work
     // if there are sharp color changes. Ideally, we would implement
@@ -711,7 +711,7 @@ Shadings.Mesh = (function MeshClosure() {
     }
   }
 
-  function Mesh(stream, matrix, xref, res) {
+  function Mesh(stream, matrix, xref, res, pdfFunctionFactory) {
     if (!isStream(stream)) {
       throw new FormatError('Mesh data is not a stream');
     }
@@ -721,13 +721,13 @@ Shadings.Mesh = (function MeshClosure() {
     this.type = 'Pattern';
     this.bbox = dict.getArray('BBox');
     var cs = dict.get('ColorSpace', 'CS');
-    cs = ColorSpace.parse(cs, xref, res);
+    cs = ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
     this.cs = cs;
     this.background = dict.has('Background') ?
       cs.getRgb(dict.get('Background'), 0) : null;
 
     var fnObj = dict.get('Function');
-    var fn = fnObj ? PDFFunction.parseArray(xref, fnObj) : null;
+    var fn = fnObj ? pdfFunctionFactory.createFromArray(fnObj) : null;
 
     this.coords = [];
     this.colors = [];

test/unit/colorspace_spec.js

@@ -16,6 +16,7 @@
 import { Dict, Name, Ref } from '../../src/core/primitives';
 import { Stream, StringStream } from '../../src/core/stream';
 import { ColorSpace } from '../../src/core/colorspace';
+import { PDFFunctionFactory } from '../../src/core/function';
 import { XRefMock } from './test_utils';
 
 describe('colorspace', function () {
@@ -54,7 +55,10 @@ describe('colorspace', function () {
       }]);
       let res = new Dict();
 
-      let colorSpace = ColorSpace.parse(cs, xref, res);
+      let pdfFunctionFactory = new PDFFunctionFactory({
+        xref,
+      });
+      let colorSpace = ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
 
       let testSrc = new Uint8Array([27, 125, 250, 131]);
       let testDest = new Uint8Array(4 * 4 * 3);
@@ -92,7 +96,10 @@ describe('colorspace', function () {
       }]);
       let res = new Dict();
 
-      let colorSpace = ColorSpace.parse(cs, xref, res);
+      let pdfFunctionFactory = new PDFFunctionFactory({
+        xref,
+      });
+      let colorSpace = ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
 
       let testSrc = new Uint8Array([27, 125, 250, 131]);
       let testDest = new Uint8Array(3 * 3 * 3);
@@ -126,7 +133,10 @@ describe('colorspace', function () {
       }]);
       let res = new Dict();
 
-      let colorSpace = ColorSpace.parse(cs, xref, res);
+      let pdfFunctionFactory = new PDFFunctionFactory({
+        xref,
+      });
+      let colorSpace = ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
 
       let testSrc = new Uint8Array([
         27, 125, 250,
@@ -169,7 +179,10 @@ describe('colorspace', function () {
       }]);
       let res = new Dict();
 
-      let colorSpace = ColorSpace.parse(cs, xref, res);
+      let pdfFunctionFactory = new PDFFunctionFactory({
+        xref,
+      });
+      let colorSpace = ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
 
       let testSrc = new Uint8Array([
         27, 125, 250,
@@ -208,7 +221,10 @@ describe('colorspace', function () {
       }]);
       let res = new Dict();
 
-      let colorSpace = ColorSpace.parse(cs, xref, res);
+      let pdfFunctionFactory = new PDFFunctionFactory({
+        xref,
+      });
+      let colorSpace = ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
 
       let testSrc = new Uint8Array([
         27, 125, 250, 128,
@@ -251,7 +267,10 @@ describe('colorspace', function () {
       }]);
       let res = new Dict();
 
-      let colorSpace = ColorSpace.parse(cs, xref, res);
+      let pdfFunctionFactory = new PDFFunctionFactory({
+        xref,
+      });
+      let colorSpace = ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
 
       let testSrc = new Uint8Array([
         27, 125, 250, 128,
@@ -298,7 +317,10 @@ describe('colorspace', function () {
       }]);
       let res = new Dict();
 
-      let colorSpace = ColorSpace.parse(cs, xref, res);
+      let pdfFunctionFactory = new PDFFunctionFactory({
+        xref,
+      });
+      let colorSpace = ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
 
       let testSrc = new Uint8Array([27, 125, 250, 131]);
       let testDest = new Uint8Array(4 * 4 * 3);
@@ -348,7 +370,10 @@ describe('colorspace', function () {
       }]);
       let res = new Dict();
 
-      let colorSpace = ColorSpace.parse(cs, xref, res);
+      let pdfFunctionFactory = new PDFFunctionFactory({
+        xref,
+      });
+      let colorSpace = ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
 
       let testSrc = new Uint8Array([
         27, 125, 250,
@@ -395,7 +420,10 @@ describe('colorspace', function () {
       }]);
       let res = new Dict();
 
-      let colorSpace = ColorSpace.parse(cs, xref, res);
+      let pdfFunctionFactory = new PDFFunctionFactory({
+        xref,
+      });
+      let colorSpace = ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
 
       let testSrc = new Uint8Array([
         27, 25, 50,
@@ -445,7 +473,10 @@ describe('colorspace', function () {
       }]);
       let res = new Dict();
 
-      let colorSpace = ColorSpace.parse(cs, xref, res);
+      let pdfFunctionFactory = new PDFFunctionFactory({
+        xref,
+      });
+      let colorSpace = ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
 
       let testSrc = new Uint8Array([2, 2, 0, 1]);
       let testDest = new Uint8Array(3 * 3 * 3);
@@ -497,7 +528,10 @@ describe('colorspace', function () {
       }]);
       let res = new Dict();
 
-      let colorSpace = ColorSpace.parse(cs, xref, res);
+      let pdfFunctionFactory = new PDFFunctionFactory({
+        xref,
+      });
+      let colorSpace = ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
 
       let testSrc = new Uint8Array([27, 25, 50, 31]);
       let testDest = new Uint8Array(3 * 3 * 3);

test/unit/document_spec.js

@@ -18,16 +18,14 @@ import { Page } from '../../src/core/document';
 describe('document', function () {
   describe('Page', function () {
     it('should create correct objId using the idFactory', function () {
-      var page1 = new Page(/* pdfManager = */ { }, /* xref = */ null,
-                           /* pageIndex = */ 0,
-                           /* pageDict = */ null, /* ref = */ null,
-                           /* fontCache = */ null,
-                           /* builtInCMapCache = */ null);
-      var page2 = new Page(/* pdfManager = */ { }, /* xref = */ null,
-                           /* pageIndex = */ 1,
-                           /* pageDict = */ null, /* ref = */ null,
-                           /* fontCache = */ null,
-                           /* builtInCMapCache = */ null);
+      var page1 = new Page({
+        pdfManager: { },
+        pageIndex: 0,
+      });
+      var page2 = new Page({
+        pdfManager: { },
+        pageIndex: 1,
+      });
 
       var idFactory1 = page1.idFactory, idFactory2 = page2.idFactory;