pdfjs-dist 2.0.550 → 2.3.200

package/lib/display/canvas.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,16 +19,16 @@
  * @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.CanvasGraphics = undefined;
+exports.CanvasGraphics = void 0;
 
-var _util = require('../shared/util');
+var _util = require("../shared/util");
 
-var _pattern_helper = require('./pattern_helper');
+var _pattern_helper = require("./pattern_helper");
 
 var MIN_FONT_SIZE = 16;
 var MAX_FONT_SIZE = 100;
@@ -41,7 +41,9 @@ var IsLittleEndianCached = {
   get value() {
     return (0, _util.shadow)(IsLittleEndianCached, 'value', (0, _util.isLittleEndian)());
   }
+
 };
+
 function addContextCurrentTransform(ctx) {
   if (!ctx.mozCurrentTransform) {
     ctx._originalSave = ctx.save;
@@ -72,59 +74,79 @@ function addContextCurrentTransform(ctx) {
         return [d / ad_bc, b / bc_ad, c / bc_ad, a / ad_bc, (d * e - c * f) / bc_ad, (b * e - a * f) / ad_bc];
       }
     });
+
     ctx.save = function ctxSave() {
       var old = this._transformMatrix;
+
       this._transformStack.push(old);
+
       this._transformMatrix = old.slice(0, 6);
+
       this._originalSave();
     };
+
     ctx.restore = function ctxRestore() {
       var prev = this._transformStack.pop();
+
       if (prev) {
         this._transformMatrix = prev;
+
         this._originalRestore();
       }
     };
+
     ctx.translate = function ctxTranslate(x, y) {
       var m = this._transformMatrix;
       m[4] = m[0] * x + m[2] * y + m[4];
       m[5] = m[1] * x + m[3] * y + m[5];
+
       this._originalTranslate(x, y);
     };
+
     ctx.scale = function ctxScale(x, y) {
       var m = this._transformMatrix;
       m[0] = m[0] * x;
       m[1] = m[1] * x;
       m[2] = m[2] * y;
       m[3] = m[3] * y;
+
       this._originalScale(x, y);
     };
+
     ctx.transform = function ctxTransform(a, b, c, d, e, f) {
       var m = this._transformMatrix;
       this._transformMatrix = [m[0] * a + m[2] * b, m[1] * a + m[3] * b, m[0] * c + m[2] * d, m[1] * c + m[3] * d, m[0] * e + m[2] * f + m[4], m[1] * e + m[3] * f + m[5]];
+
       ctx._originalTransform(a, b, c, d, e, f);
     };
+
     ctx.setTransform = function ctxSetTransform(a, b, c, d, e, f) {
       this._transformMatrix = [a, b, c, d, e, f];
+
       ctx._originalSetTransform(a, b, c, d, e, f);
     };
+
     ctx.rotate = function ctxRotate(angle) {
       var cosValue = Math.cos(angle);
       var sinValue = Math.sin(angle);
       var m = this._transformMatrix;
       this._transformMatrix = [m[0] * cosValue + m[2] * sinValue, m[1] * cosValue + m[3] * sinValue, m[0] * -sinValue + m[2] * cosValue, m[1] * -sinValue + m[3] * cosValue, m[4], m[5]];
+
       this._originalRotate(angle);
     };
   }
 }
+
 var CachedCanvases = function CachedCanvasesClosure() {
   function CachedCanvases(canvasFactory) {
     this.canvasFactory = canvasFactory;
     this.cache = Object.create(null);
   }
+
   CachedCanvases.prototype = {
     getCanvas: function CachedCanvases_getCanvas(id, width, height, trackTransform) {
       var canvasEntry;
+
       if (this.cache[id] !== undefined) {
         canvasEntry = this.cache[id];
         this.canvasFactory.reset(canvasEntry, width, height);
@@ -133,9 +155,11 @@ var CachedCanvases = function CachedCanvasesClosure() {
         canvasEntry = this.canvasFactory.create(width, height);
         this.cache[id] = canvasEntry;
       }
+
       if (trackTransform) {
         addContextCurrentTransform(canvasEntry.context);
       }
+
       return canvasEntry;
     },
     clear: function clear() {
@@ -148,6 +172,7 @@ var CachedCanvases = function CachedCanvasesClosure() {
   };
   return CachedCanvases;
 }();
+
 function compileType3Glyph(imgData) {
   var POINT_TO_PROCESS_LIMIT = 1000;
   var width = imgData.width,
@@ -163,96 +188,126 @@ function compileType3Glyph(imgData) {
   var data = new Uint8Array(lineSize * height),
       pos = 0,
       ii;
+
   for (i = 0, ii = data0.length; i < ii; i++) {
     var mask = 128,
         elem = data0[i];
+
     while (mask > 0) {
       data[pos++] = elem & mask ? 0 : 255;
       mask >>= 1;
     }
   }
+
   var count = 0;
   pos = 0;
+
   if (data[pos] !== 0) {
     points[0] = 1;
     ++count;
   }
+
   for (j = 1; j < width; j++) {
     if (data[pos] !== data[pos + 1]) {
       points[j] = data[pos] ? 2 : 1;
       ++count;
     }
+
     pos++;
   }
+
   if (data[pos] !== 0) {
     points[j] = 2;
     ++count;
   }
+
   for (i = 1; i < height; i++) {
     pos = i * lineSize;
     j0 = i * width1;
+
     if (data[pos - lineSize] !== data[pos]) {
       points[j0] = data[pos] ? 1 : 8;
       ++count;
     }
+
     var sum = (data[pos] ? 4 : 0) + (data[pos - lineSize] ? 8 : 0);
+
     for (j = 1; j < width; j++) {
       sum = (sum >> 2) + (data[pos + 1] ? 4 : 0) + (data[pos - lineSize + 1] ? 8 : 0);
+
       if (POINT_TYPES[sum]) {
         points[j0 + j] = POINT_TYPES[sum];
         ++count;
       }
+
       pos++;
     }
+
     if (data[pos - lineSize] !== data[pos]) {
       points[j0 + j] = data[pos] ? 2 : 4;
       ++count;
     }
+
     if (count > POINT_TO_PROCESS_LIMIT) {
       return null;
     }
   }
+
   pos = lineSize * (height - 1);
   j0 = i * width1;
+
   if (data[pos] !== 0) {
     points[j0] = 8;
     ++count;
   }
+
   for (j = 1; j < width; j++) {
     if (data[pos] !== data[pos + 1]) {
       points[j0 + j] = data[pos] ? 4 : 8;
       ++count;
     }
+
     pos++;
   }
+
   if (data[pos] !== 0) {
     points[j0 + j] = 4;
     ++count;
   }
+
   if (count > POINT_TO_PROCESS_LIMIT) {
     return null;
   }
+
   var steps = new Int32Array([0, width1, -1, 0, -width1, 0, 0, 0, 1]);
   var outlines = [];
+
   for (i = 0; count && i <= height; i++) {
     var p = i * width1;
     var end = p + width;
+
     while (p < end && !points[p]) {
       p++;
     }
+
     if (p === end) {
       continue;
     }
+
     var coords = [p % width1, i];
     var type = points[p],
         p0 = p,
         pp;
+
     do {
       var step = steps[type];
+
       do {
         p += step;
       } while (!points[p]);
+
       pp = points[p];
+
       if (pp !== 5 && pp !== 10) {
         type = pp;
         points[p] = 0;
@@ -260,31 +315,42 @@ function compileType3Glyph(imgData) {
         type = pp & 0x33 * type >> 4;
         points[p] &= type >> 2 | type << 2;
       }
+
       coords.push(p % width1);
       coords.push(p / width1 | 0);
-      --count;
+
+      if (!points[p]) {
+        --count;
+      }
     } while (p0 !== p);
+
     outlines.push(coords);
     --i;
   }
+
   var drawOutline = function drawOutline(c) {
     c.save();
     c.scale(1 / width, -1 / height);
     c.translate(0, -height);
     c.beginPath();
+
     for (var i = 0, ii = outlines.length; i < ii; i++) {
       var o = outlines[i];
       c.moveTo(o[0], o[1]);
+
       for (var j = 2, jj = o.length; j < jj; j += 2) {
         c.lineTo(o[j], o[j + 1]);
       }
     }
+
     c.fill();
     c.beginPath();
     c.restore();
   };
+
   return drawOutline;
 }
+
 var CanvasExtraState = function CanvasExtraStateClosure() {
   function CanvasExtraState() {
     this.alphaIsShape = false;
@@ -312,6 +378,7 @@ var CanvasExtraState = function CanvasExtraStateClosure() {
     this.activeSMask = null;
     this.resumeSMaskCtx = null;
   }
+
   CanvasExtraState.prototype = {
     clone: function CanvasExtraState_clone() {
       return Object.create(this);
@@ -323,9 +390,11 @@ var CanvasExtraState = function CanvasExtraStateClosure() {
   };
   return CanvasExtraState;
 }();
+
 var CanvasGraphics = function CanvasGraphicsClosure() {
   var EXECUTION_TIME = 15;
   var EXECUTION_STEPS = 10;
+
   function CanvasGraphics(canvasCtx, commonObjs, objs, canvasFactory, webGLContext, imageLayer) {
     this.ctx = canvasCtx;
     this.current = new CanvasExtraState();
@@ -348,16 +417,20 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
     this.smaskCounter = 0;
     this.tempSMask = null;
     this.cachedCanvases = new CachedCanvases(this.canvasFactory);
+
     if (canvasCtx) {
       addContextCurrentTransform(canvasCtx);
     }
-    this.cachedGetSinglePixelWidth = null;
+
+    this._cachedGetSinglePixelWidth = null;
   }
+
   function putBinaryImageData(ctx, imgData) {
     if (typeof ImageData !== 'undefined' && imgData instanceof ImageData) {
       ctx.putImageData(imgData, 0, 0);
       return;
     }
+
     var height = imgData.height,
         width = imgData.width;
     var partialChunkHeight = height % FULL_CHUNK_HEIGHT;
@@ -369,6 +442,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
     var src = imgData.data;
     var dest = chunkImgData.data;
     var i, j, thisChunkHeight, elemsInThisChunk;
+
     if (imgData.kind === _util.ImageKind.GRAYSCALE_1BPP) {
       var srcLength = src.byteLength;
       var dest32 = new Uint32Array(dest.buffer, 0, dest.byteLength >> 2);
@@ -376,9 +450,11 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       var fullSrcDiff = width + 7 >> 3;
       var white = 0xFFFFFFFF;
       var black = IsLittleEndianCached.value ? 0xFF000000 : 0x000000FF;
+
       for (i = 0; i < totalChunks; i++) {
         thisChunkHeight = i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight;
         destPos = 0;
+
         for (j = 0; j < thisChunkHeight; j++) {
           var srcDiff = srcLength - srcPos;
           var k = 0;
@@ -386,6 +462,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
           var kEndUnrolled = kEnd & ~7;
           var mask = 0;
           var srcByte = 0;
+
           for (; k < kEndUnrolled; k += 8) {
             srcByte = src[srcPos++];
             dest32[destPos++] = srcByte & 128 ? white : black;
@@ -397,29 +474,35 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
             dest32[destPos++] = srcByte & 2 ? white : black;
             dest32[destPos++] = srcByte & 1 ? white : black;
           }
+
           for (; k < kEnd; k++) {
             if (mask === 0) {
               srcByte = src[srcPos++];
               mask = 128;
             }
+
             dest32[destPos++] = srcByte & mask ? white : black;
             mask >>= 1;
           }
         }
+
         while (destPos < dest32DataLength) {
           dest32[destPos++] = 0;
         }
+
         ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
       }
     } else if (imgData.kind === _util.ImageKind.RGBA_32BPP) {
       j = 0;
       elemsInThisChunk = width * FULL_CHUNK_HEIGHT * 4;
+
       for (i = 0; i < fullChunks; i++) {
         dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));
         srcPos += elemsInThisChunk;
         ctx.putImageData(chunkImgData, 0, j);
         j += FULL_CHUNK_HEIGHT;
       }
+
       if (i < totalChunks) {
         elemsInThisChunk = width * partialChunkHeight * 4;
         dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));
@@ -428,24 +511,29 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
     } else if (imgData.kind === _util.ImageKind.RGB_24BPP) {
       thisChunkHeight = FULL_CHUNK_HEIGHT;
       elemsInThisChunk = width * thisChunkHeight;
+
       for (i = 0; i < totalChunks; i++) {
         if (i >= fullChunks) {
           thisChunkHeight = partialChunkHeight;
           elemsInThisChunk = width * thisChunkHeight;
         }
+
         destPos = 0;
+
         for (j = elemsInThisChunk; j--;) {
           dest[destPos++] = src[srcPos++];
           dest[destPos++] = src[srcPos++];
           dest[destPos++] = src[srcPos++];
           dest[destPos++] = 255;
         }
+
         ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
       }
     } else {
-      throw new Error('bad image kind: ' + imgData.kind);
+      throw new Error("bad image kind: ".concat(imgData.kind));
     }
   }
+
   function putBinaryImageMask(ctx, imgData) {
     var height = imgData.height,
         width = imgData.width;
@@ -456,37 +544,47 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
     var srcPos = 0;
     var src = imgData.data;
     var dest = chunkImgData.data;
+
     for (var i = 0; i < totalChunks; i++) {
       var thisChunkHeight = i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight;
       var destPos = 3;
+
       for (var j = 0; j < thisChunkHeight; j++) {
         var mask = 0;
+
         for (var k = 0; k < width; k++) {
           if (!mask) {
             var elem = src[srcPos++];
             mask = 128;
           }
+
           dest[destPos] = elem & mask ? 0 : 255;
           destPos += 4;
           mask >>= 1;
         }
       }
+
       ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
     }
   }
+
   function copyCtxState(sourceCtx, destCtx) {
     var properties = ['strokeStyle', 'fillStyle', 'fillRule', 'globalAlpha', 'lineWidth', 'lineCap', 'lineJoin', 'miterLimit', 'globalCompositeOperation', 'font'];
+
     for (var i = 0, ii = properties.length; i < ii; i++) {
       var property = properties[i];
+
       if (sourceCtx[property] !== undefined) {
         destCtx[property] = sourceCtx[property];
       }
     }
+
     if (sourceCtx.setLineDash !== undefined) {
       destCtx.setLineDash(sourceCtx.getLineDash());
       destCtx.lineDashOffset = sourceCtx.lineDashOffset;
     }
   }
+
   function resetCtxToDefault(ctx) {
     ctx.strokeStyle = '#000000';
     ctx.fillStyle = '#000000';
@@ -498,15 +596,19 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
     ctx.miterLimit = 10;
     ctx.globalCompositeOperation = 'source-over';
     ctx.font = '10px sans-serif';
+
     if (ctx.setLineDash !== undefined) {
       ctx.setLineDash([]);
       ctx.lineDashOffset = 0;
     }
   }
+
   function composeSMaskBackdrop(bytes, r0, g0, b0) {
     var length = bytes.length;
+
     for (var i = 3; i < length; i += 4) {
       var alpha = bytes[i];
+
       if (alpha === 0) {
         bytes[i - 3] = r0;
         bytes[i - 2] = g0;
@@ -519,50 +621,62 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       }
     }
   }
+
   function composeSMaskAlpha(maskData, layerData, transferMap) {
     var length = maskData.length;
     var scale = 1 / 255;
+
     for (var i = 3; i < length; i += 4) {
       var alpha = transferMap ? transferMap[maskData[i]] : maskData[i];
       layerData[i] = layerData[i] * alpha * scale | 0;
     }
   }
+
   function composeSMaskLuminosity(maskData, layerData, transferMap) {
     var length = maskData.length;
+
     for (var i = 3; i < length; i += 4) {
       var y = maskData[i - 3] * 77 + maskData[i - 2] * 152 + maskData[i - 1] * 28;
       layerData[i] = transferMap ? layerData[i] * transferMap[y >> 8] >> 8 : layerData[i] * y >> 16;
     }
   }
+
   function genericComposeSMask(maskCtx, layerCtx, width, height, subtype, backdrop, transferMap) {
     var hasBackdrop = !!backdrop;
     var r0 = hasBackdrop ? backdrop[0] : 0;
     var g0 = hasBackdrop ? backdrop[1] : 0;
     var b0 = hasBackdrop ? backdrop[2] : 0;
     var composeFn;
+
     if (subtype === 'Luminosity') {
       composeFn = composeSMaskLuminosity;
     } else {
       composeFn = composeSMaskAlpha;
     }
+
     var PIXELS_TO_PROCESS = 1048576;
     var chunkSize = Math.min(height, Math.ceil(PIXELS_TO_PROCESS / width));
+
     for (var row = 0; row < height; row += chunkSize) {
       var chunkHeight = Math.min(chunkSize, height - row);
       var maskData = maskCtx.getImageData(0, row, width, chunkHeight);
       var layerData = layerCtx.getImageData(0, row, width, chunkHeight);
+
       if (hasBackdrop) {
         composeSMaskBackdrop(maskData.data, r0, g0, b0);
       }
+
       composeFn(maskData.data, layerData.data, transferMap);
       maskCtx.putImageData(layerData, 0, row);
     }
   }
+
   function composeSMask(ctx, smask, layerCtx, webGLContext) {
     var mask = smask.canvas;
     var maskCtx = smask.context;
     ctx.setTransform(smask.scaleX, 0, 0, smask.scaleY, smask.offsetX, smask.offsetY);
     var backdrop = smask.backdrop || null;
+
     if (!smask.transferMap && webGLContext.isEnabled) {
       var composed = webGLContext.composeSMask({
         layer: layerCtx.canvas,
@@ -576,9 +690,11 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       ctx.drawImage(composed, smask.offsetX, smask.offsetY);
       return;
     }
+
     genericComposeSMask(maskCtx, layerCtx, mask.width, mask.height, smask.subtype, backdrop, smask.transferMap);
     ctx.drawImage(mask, 0, 0);
   }
+
   var LINE_CAP_STYLES = ['butt', 'round', 'square'];
   var LINE_JOIN_STYLES = ['miter', 'round', 'bevel'];
   var NORMAL_CLIP = {};
@@ -587,16 +703,17 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
     beginDrawing: function beginDrawing(_ref) {
       var transform = _ref.transform,
           viewport = _ref.viewport,
-          transparency = _ref.transparency,
+          _ref$transparency = _ref.transparency,
+          transparency = _ref$transparency === void 0 ? false : _ref$transparency,
           _ref$background = _ref.background,
-          background = _ref$background === undefined ? null : _ref$background;
-
+          background = _ref$background === void 0 ? null : _ref$background;
       var width = this.ctx.canvas.width;
       var height = this.ctx.canvas.height;
       this.ctx.save();
       this.ctx.fillStyle = background || 'rgb(255, 255, 255)';
       this.ctx.fillRect(0, 0, width, height);
       this.ctx.restore();
+
       if (transparency) {
         var transparentCanvas = this.cachedCanvases.getCanvas('transparent', width, height, true);
         this.compositeCtx = this.ctx;
@@ -605,61 +722,91 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
         this.ctx.save();
         this.ctx.transform.apply(this.ctx, this.compositeCtx.mozCurrentTransform);
       }
+
       this.ctx.save();
       resetCtxToDefault(this.ctx);
+
       if (transform) {
         this.ctx.transform.apply(this.ctx, transform);
       }
+
       this.ctx.transform.apply(this.ctx, viewport.transform);
       this.baseTransform = this.ctx.mozCurrentTransform.slice();
+
       if (this.imageLayer) {
         this.imageLayer.beginLayout();
       }
     },
-
     executeOperatorList: function CanvasGraphics_executeOperatorList(operatorList, executionStartIdx, continueCallback, stepper) {
       var argsArray = operatorList.argsArray;
       var fnArray = operatorList.fnArray;
       var i = executionStartIdx || 0;
       var argsArrayLen = argsArray.length;
+
       if (argsArrayLen === i) {
         return i;
       }
+
       var chunkOperations = argsArrayLen - i > EXECUTION_STEPS && typeof continueCallback === 'function';
       var endTime = chunkOperations ? Date.now() + EXECUTION_TIME : 0;
       var steps = 0;
       var commonObjs = this.commonObjs;
       var objs = this.objs;
       var fnId;
+
       while (true) {
         if (stepper !== undefined && i === stepper.nextBreakPoint) {
           stepper.breakIt(i, continueCallback);
           return i;
         }
+
         fnId = fnArray[i];
+
         if (fnId !== _util.OPS.dependency) {
           this[fnId].apply(this, argsArray[i]);
         } else {
-          var deps = argsArray[i];
-          for (var n = 0, nn = deps.length; n < nn; n++) {
-            var depObjId = deps[n];
-            var common = depObjId[0] === 'g' && depObjId[1] === '_';
-            var objsPool = common ? commonObjs : objs;
-            if (!objsPool.isResolved(depObjId)) {
-              objsPool.get(depObjId, continueCallback);
-              return i;
+          var _iteratorNormalCompletion = true;
+          var _didIteratorError = false;
+          var _iteratorError = undefined;
+
+          try {
+            for (var _iterator = argsArray[i][Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+              var depObjId = _step.value;
+              var objsPool = depObjId.startsWith('g_') ? commonObjs : objs;
+
+              if (!objsPool.has(depObjId)) {
+                objsPool.get(depObjId, continueCallback);
+                return i;
+              }
+            }
+          } catch (err) {
+            _didIteratorError = true;
+            _iteratorError = err;
+          } finally {
+            try {
+              if (!_iteratorNormalCompletion && _iterator["return"] != null) {
+                _iterator["return"]();
+              }
+            } finally {
+              if (_didIteratorError) {
+                throw _iteratorError;
+              }
             }
           }
         }
+
         i++;
+
         if (i === argsArrayLen) {
           return i;
         }
+
         if (chunkOperations && ++steps > EXECUTION_STEPS) {
           if (Date.now() > endTime) {
             continueCallback();
             return i;
           }
+
           steps = 0;
         }
       }
@@ -668,7 +815,9 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       if (this.current.activeSMask !== null) {
         this.endSMaskGroup();
       }
+
       this.ctx.restore();
+
       if (this.transparentCanvas) {
         this.ctx = this.compositeCtx;
         this.ctx.save();
@@ -677,8 +826,10 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
         this.ctx.restore();
         this.transparentCanvas = null;
       }
+
       this.cachedCanvases.clear();
       this.webGLContext.clear();
+
       if (this.imageLayer) {
         this.imageLayer.endLayout();
       }
@@ -698,53 +849,66 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
     },
     setDash: function CanvasGraphics_setDash(dashArray, dashPhase) {
       var ctx = this.ctx;
+
       if (ctx.setLineDash !== undefined) {
         ctx.setLineDash(dashArray);
         ctx.lineDashOffset = dashPhase;
       }
     },
-    setRenderingIntent: function CanvasGraphics_setRenderingIntent(intent) {},
-    setFlatness: function CanvasGraphics_setFlatness(flatness) {},
+    setRenderingIntent: function setRenderingIntent(intent) {},
+    setFlatness: function setFlatness(flatness) {},
     setGState: function CanvasGraphics_setGState(states) {
       for (var i = 0, ii = states.length; i < ii; i++) {
         var state = states[i];
         var key = state[0];
         var value = state[1];
+
         switch (key) {
           case 'LW':
             this.setLineWidth(value);
             break;
+
           case 'LC':
             this.setLineCap(value);
             break;
+
           case 'LJ':
             this.setLineJoin(value);
             break;
+
           case 'ML':
             this.setMiterLimit(value);
             break;
+
           case 'D':
             this.setDash(value[0], value[1]);
             break;
+
           case 'RI':
             this.setRenderingIntent(value);
             break;
+
           case 'FL':
             this.setFlatness(value);
             break;
+
           case 'Font':
             this.setFont(value[0], value[1]);
             break;
+
           case 'CA':
             this.current.strokeAlpha = state[1];
             break;
+
           case 'ca':
             this.current.fillAlpha = state[1];
             this.ctx.globalAlpha = state[1];
             break;
+
           case 'BM':
             this.ctx.globalCompositeOperation = value;
             break;
+
           case 'SMask':
             if (this.current.activeSMask) {
               if (this.stateStack.length > 0 && this.stateStack[this.stateStack.length - 1].activeSMask === this.current.activeSMask) {
@@ -753,10 +917,13 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
                 this.endSMaskGroup();
               }
             }
+
             this.current.activeSMask = value ? this.tempSMask : null;
+
             if (this.current.activeSMask) {
               this.beginSMaskGroup();
             }
+
             this.tempSMask = null;
             break;
         }
@@ -791,7 +958,9 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       this.ctx.save();
       copyCtxState(groupCtx, this.ctx);
       this.current.resumeSMaskCtx = groupCtx;
+
       var deltaTransform = _util.Util.transform(this.current.activeSMask.startTransformInverse, groupCtx.mozCurrentTransform);
+
       this.ctx.transform.apply(this.ctx, deltaTransform);
       groupCtx.save();
       groupCtx.setTransform(1, 0, 0, 1, 0, 0);
@@ -812,7 +981,9 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       composeSMask(this.ctx, this.current.activeSMask, groupCtx, this.webGLContext);
       this.ctx.restore();
       copyCtxState(groupCtx, this.ctx);
+
       var deltaTransform = _util.Util.transform(this.current.activeSMask.startTransformInverse, groupCtx.mozCurrentTransform);
+
       this.ctx.transform.apply(this.ctx, deltaTransform);
     },
     save: function CanvasGraphics_save() {
@@ -826,25 +997,28 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       if (this.current.resumeSMaskCtx) {
         this.resumeSMaskGroup();
       }
+
       if (this.current.activeSMask !== null && (this.stateStack.length === 0 || this.stateStack[this.stateStack.length - 1].activeSMask !== this.current.activeSMask)) {
         this.endSMaskGroup();
       }
+
       if (this.stateStack.length !== 0) {
         this.current = this.stateStack.pop();
         this.ctx.restore();
         this.pendingClip = null;
-        this.cachedGetSinglePixelWidth = null;
+        this._cachedGetSinglePixelWidth = null;
       }
     },
     transform: function CanvasGraphics_transform(a, b, c, d, e, f) {
       this.ctx.transform(a, b, c, d, e, f);
-      this.cachedGetSinglePixelWidth = null;
+      this._cachedGetSinglePixelWidth = null;
     },
     constructPath: function CanvasGraphics_constructPath(ops, args) {
       var ctx = this.ctx;
       var current = this.current;
       var x = current.x,
           y = current.y;
+
       for (var i = 0, j = 0, ii = ops.length; i < ii; i++) {
         switch (ops[i] | 0) {
           case _util.OPS.rectangle:
@@ -852,12 +1026,15 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
             y = args[j++];
             var width = args[j++];
             var height = args[j++];
+
             if (width === 0) {
               width = this.getSinglePixelWidth();
             }
+
             if (height === 0) {
               height = this.getSinglePixelWidth();
             }
+
             var xw = x + width;
             var yh = y + height;
             this.ctx.moveTo(x, y);
@@ -867,39 +1044,46 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
             this.ctx.lineTo(x, y);
             this.ctx.closePath();
             break;
+
           case _util.OPS.moveTo:
             x = args[j++];
             y = args[j++];
             ctx.moveTo(x, y);
             break;
+
           case _util.OPS.lineTo:
             x = args[j++];
             y = args[j++];
             ctx.lineTo(x, y);
             break;
+
           case _util.OPS.curveTo:
             x = args[j + 4];
             y = args[j + 5];
             ctx.bezierCurveTo(args[j], args[j + 1], args[j + 2], args[j + 3], x, y);
             j += 6;
             break;
+
           case _util.OPS.curveTo2:
             ctx.bezierCurveTo(x, y, args[j], args[j + 1], args[j + 2], args[j + 3]);
             x = args[j + 2];
             y = args[j + 3];
             j += 4;
             break;
+
           case _util.OPS.curveTo3:
             x = args[j + 2];
             y = args[j + 3];
             ctx.bezierCurveTo(args[j], args[j + 1], x, y, x, y);
             j += 4;
             break;
+
           case _util.OPS.closePath:
             ctx.closePath();
             break;
         }
       }
+
       current.setCurrentPoint(x, y);
     },
     closePath: function CanvasGraphics_closePath() {
@@ -909,19 +1093,27 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       consumePath = typeof consumePath !== 'undefined' ? consumePath : true;
       var ctx = this.ctx;
       var strokeColor = this.current.strokeColor;
-      ctx.lineWidth = Math.max(this.getSinglePixelWidth() * MIN_WIDTH_FACTOR, this.current.lineWidth);
       ctx.globalAlpha = this.current.strokeAlpha;
+
       if (strokeColor && strokeColor.hasOwnProperty('type') && strokeColor.type === 'Pattern') {
         ctx.save();
+        var transform = ctx.mozCurrentTransform;
+
+        var scale = _util.Util.singularValueDecompose2dScale(transform)[0];
+
         ctx.strokeStyle = strokeColor.getPattern(ctx, this);
+        ctx.lineWidth = Math.max(this.getSinglePixelWidth() * MIN_WIDTH_FACTOR, this.current.lineWidth * scale);
         ctx.stroke();
         ctx.restore();
       } else {
+        ctx.lineWidth = Math.max(this.getSinglePixelWidth() * MIN_WIDTH_FACTOR, this.current.lineWidth);
         ctx.stroke();
       }
+
       if (consumePath) {
         this.consumePath();
       }
+
       ctx.globalAlpha = this.current.fillAlpha;
     },
     closeStroke: function CanvasGraphics_closeStroke() {
@@ -934,23 +1126,29 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       var fillColor = this.current.fillColor;
       var isPatternFill = this.current.patternFill;
       var needRestore = false;
+
       if (isPatternFill) {
         ctx.save();
+
         if (this.baseTransform) {
           ctx.setTransform.apply(ctx, this.baseTransform);
         }
+
         ctx.fillStyle = fillColor.getPattern(ctx, this);
         needRestore = true;
       }
+
       if (this.pendingEOFill) {
         ctx.fill('evenodd');
         this.pendingEOFill = false;
       } else {
         ctx.fill();
       }
+
       if (needRestore) {
         ctx.restore();
       }
+
       if (consumePath) {
         this.consumePath();
       }
@@ -995,18 +1193,22 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
     endText: function CanvasGraphics_endText() {
       var paths = this.pendingTextPaths;
       var ctx = this.ctx;
+
       if (paths === undefined) {
         ctx.beginPath();
         return;
       }
+
       ctx.save();
       ctx.beginPath();
+
       for (var i = 0; i < paths.length; i++) {
         var path = paths[i];
         ctx.setTransform.apply(ctx, path.transform);
         ctx.translate(path.x, path.y);
         path.addToPath(ctx, path.fontSize);
       }
+
       ctx.restore();
       ctx.clip();
       ctx.beginPath();
@@ -1027,32 +1229,38 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
     setFont: function CanvasGraphics_setFont(fontRefName, size) {
       var fontObj = this.commonObjs.get(fontRefName);
       var current = this.current;
+
       if (!fontObj) {
-        throw new Error('Can\'t find font for ' + fontRefName);
+        throw new Error("Can't find font for ".concat(fontRefName));
       }
+
       current.fontMatrix = fontObj.fontMatrix ? fontObj.fontMatrix : _util.FONT_IDENTITY_MATRIX;
+
       if (current.fontMatrix[0] === 0 || current.fontMatrix[3] === 0) {
         (0, _util.warn)('Invalid font matrix for font ' + fontRefName);
       }
+
       if (size < 0) {
         size = -size;
         current.fontDirection = -1;
       } else {
         current.fontDirection = 1;
       }
+
       this.current.font = fontObj;
       this.current.fontSize = size;
+
       if (fontObj.isType3Font) {
         return;
       }
+
       var name = fontObj.loadedName || 'sans-serif';
       var bold = fontObj.black ? '900' : fontObj.bold ? 'bold' : 'normal';
       var italic = fontObj.italic ? 'italic' : 'normal';
-      var typeface = '"' + name + '", ' + fontObj.fallbackName;
+      var typeface = "\"".concat(name, "\", ").concat(fontObj.fallbackName);
       var browserFontSize = size < MIN_FONT_SIZE ? MIN_FONT_SIZE : size > MAX_FONT_SIZE ? MAX_FONT_SIZE : size;
       this.current.fontSizeScale = size / browserFontSize;
-      var rule = italic + ' ' + bold + ' ' + browserFontSize + 'px ' + typeface;
-      this.ctx.font = rule;
+      this.ctx.font = "".concat(italic, " ").concat(bold, " ").concat(browserFontSize, "px ").concat(typeface);
     },
     setTextRenderingMode: function CanvasGraphics_setTextRenderingMode(mode) {
       this.current.textRenderingMode = mode;
@@ -1087,32 +1295,40 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       var isAddToPathSet = !!(textRenderingMode & _util.TextRenderingMode.ADD_TO_PATH_FLAG);
       var patternFill = current.patternFill && font.data;
       var addToPath;
+
       if (font.disableFontFace || isAddToPathSet || patternFill) {
         addToPath = font.getPathGenerator(this.commonObjs, character);
       }
+
       if (font.disableFontFace || patternFill) {
         ctx.save();
         ctx.translate(x, y);
         ctx.beginPath();
         addToPath(ctx, fontSize);
+
         if (patternTransform) {
           ctx.setTransform.apply(ctx, patternTransform);
         }
+
         if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
           ctx.fill();
         }
+
         if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
           ctx.stroke();
         }
+
         ctx.restore();
       } else {
         if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
           ctx.fillText(character, x, y);
         }
+
         if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
           ctx.strokeText(character, x, y);
         }
       }
+
       if (isAddToPathSet) {
         var paths = this.pendingTextPaths || (this.pendingTextPaths = []);
         paths.push({
@@ -1126,29 +1342,38 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
     },
 
     get isFontSubpixelAAEnabled() {
-      var ctx = this.canvasFactory.create(10, 10).context;
+      var _this$cachedCanvases$ = this.cachedCanvases.getCanvas('isFontSubpixelAAEnabled', 10, 10),
+          ctx = _this$cachedCanvases$.context;
+
       ctx.scale(1.5, 1);
       ctx.fillText('I', 0, 10);
       var data = ctx.getImageData(0, 0, 10, 10).data;
       var enabled = false;
+
       for (var i = 3; i < data.length; i += 4) {
         if (data[i] > 0 && data[i] < 255) {
           enabled = true;
           break;
         }
       }
+
       return (0, _util.shadow)(this, 'isFontSubpixelAAEnabled', enabled);
     },
+
     showText: function CanvasGraphics_showText(glyphs) {
       var current = this.current;
       var font = current.font;
+
       if (font.isType3Font) {
         return this.showType3Text(glyphs);
       }
+
       var fontSize = current.fontSize;
+
       if (fontSize === 0) {
-        return;
+        return undefined;
       }
+
       var ctx = this.ctx;
       var fontSizeScale = current.fontSizeScale;
       var charSpacing = current.charSpacing;
@@ -1162,7 +1387,8 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       var widthAdvanceScale = fontSize * current.fontMatrix[0];
       var simpleFillText = current.textRenderingMode === _util.TextRenderingMode.FILL && !font.disableFontFace && !current.patternFill;
       ctx.save();
-      var patternTransform = void 0;
+      var patternTransform;
+
       if (current.patternFill) {
         ctx.save();
         var pattern = current.fillColor.getPattern(ctx, this);
@@ -1170,43 +1396,54 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
         ctx.restore();
         ctx.fillStyle = pattern;
       }
+
       ctx.transform.apply(ctx, current.textMatrix);
       ctx.translate(current.x, current.y + current.textRise);
+
       if (fontDirection > 0) {
         ctx.scale(textHScale, -1);
       } else {
         ctx.scale(textHScale, 1);
       }
+
       var lineWidth = current.lineWidth;
       var scale = current.textMatrixScale;
+
       if (scale === 0 || lineWidth === 0) {
         var fillStrokeMode = current.textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK;
+
         if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
-          this.cachedGetSinglePixelWidth = null;
+          this._cachedGetSinglePixelWidth = null;
           lineWidth = this.getSinglePixelWidth() * MIN_WIDTH_FACTOR;
         }
       } else {
         lineWidth /= scale;
       }
+
       if (fontSizeScale !== 1.0) {
         ctx.scale(fontSizeScale, fontSizeScale);
         lineWidth /= fontSizeScale;
       }
+
       ctx.lineWidth = lineWidth;
       var x = 0,
           i;
+
       for (i = 0; i < glyphsLength; ++i) {
         var glyph = glyphs[i];
+
         if ((0, _util.isNum)(glyph)) {
           x += spacingDir * glyph * fontSize / 1000;
           continue;
         }
+
         var restoreNeeded = false;
         var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
         var character = glyph.fontChar;
         var accent = glyph.accent;
         var scaledX, scaledY, scaledAccentX, scaledAccentY;
         var width = glyph.width;
+
         if (vertical) {
           var vmetric, vx, vy;
           vmetric = glyph.vmetric || defaultVMetrics;
@@ -1220,8 +1457,10 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
           scaledX = x / fontSizeScale;
           scaledY = 0;
         }
+
         if (font.remeasure && width > 0) {
           var measuredWidth = ctx.measureText(character).width * 1000 / fontSize * fontSizeScale;
+
           if (width < measuredWidth && this.isFontSubpixelAAEnabled) {
             var characterScaleX = width / measuredWidth;
             restoreNeeded = true;
@@ -1232,11 +1471,13 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
             scaledX += (width - measuredWidth) / 2000 * fontSize / fontSizeScale;
           }
         }
+
         if (glyph.isInFont || font.missingFile) {
           if (simpleFillText && !accent) {
             ctx.fillText(character, scaledX, scaledY);
           } else {
             this.paintChar(character, scaledX, scaledY, patternTransform);
+
             if (accent) {
               scaledAccentX = scaledX + accent.offset.x / fontSizeScale;
               scaledAccentY = scaledY - accent.offset.y / fontSizeScale;
@@ -1244,17 +1485,21 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
             }
           }
         }
+
         var charWidth = width * widthAdvanceScale + spacing * fontDirection;
         x += charWidth;
+
         if (restoreNeeded) {
           ctx.restore();
         }
       }
+
       if (vertical) {
         current.y -= x * textHScale;
       } else {
         current.x += x * textHScale;
       }
+
       ctx.restore();
     },
     showType3Text: function CanvasGraphics_showType3Text(glyphs) {
@@ -1271,39 +1516,49 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       var glyphsLength = glyphs.length;
       var isTextInvisible = current.textRenderingMode === _util.TextRenderingMode.INVISIBLE;
       var i, glyph, width, spacingLength;
+
       if (isTextInvisible || fontSize === 0) {
         return;
       }
-      this.cachedGetSinglePixelWidth = null;
+
+      this._cachedGetSinglePixelWidth = null;
       ctx.save();
       ctx.transform.apply(ctx, current.textMatrix);
       ctx.translate(current.x, current.y);
       ctx.scale(textHScale, fontDirection);
+
       for (i = 0; i < glyphsLength; ++i) {
         glyph = glyphs[i];
+
         if ((0, _util.isNum)(glyph)) {
           spacingLength = spacingDir * glyph * fontSize / 1000;
           this.ctx.translate(spacingLength, 0);
           current.x += spacingLength * textHScale;
           continue;
         }
+
         var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
         var operatorList = font.charProcOperatorList[glyph.operatorListId];
+
         if (!operatorList) {
-          (0, _util.warn)('Type3 character "' + glyph.operatorListId + '" is not available.');
+          (0, _util.warn)("Type3 character \"".concat(glyph.operatorListId, "\" is not available."));
           continue;
         }
+
         this.processingType3 = glyph;
         this.save();
         ctx.scale(fontSize, fontSize);
         ctx.transform.apply(ctx, fontMatrix);
         this.executeOperatorList(operatorList);
         this.restore();
+
         var transformed = _util.Util.applyTransform([glyph.width, 0], fontMatrix);
+
         width = transformed[0] * fontSize + spacing;
         ctx.translate(width, 0);
         current.x += width * textHScale;
       }
+
       ctx.restore();
       this.processingType3 = null;
     },
@@ -1317,6 +1572,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       var _this = this;
 
       var pattern;
+
       if (IR[0] === 'TilingPattern') {
         var color = IR[1];
         var baseTransform = this.baseTransform || this.ctx.mozCurrentTransform.slice();
@@ -1329,6 +1585,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       } else {
         pattern = (0, _pattern_helper.getShadingPatternFromIR)(IR);
       }
+
       return pattern;
     },
     setStrokeColorN: function CanvasGraphics_setStrokeColorN() {
@@ -1340,11 +1597,13 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
     },
     setStrokeRGBColor: function CanvasGraphics_setStrokeRGBColor(r, g, b) {
       var color = _util.Util.makeCssRgb(r, g, b);
+
       this.ctx.strokeStyle = color;
       this.current.strokeColor = color;
     },
     setFillRGBColor: function CanvasGraphics_setFillRGBColor(r, g, b) {
       var color = _util.Util.makeCssRgb(r, g, b);
+
       this.ctx.fillStyle = color;
       this.current.fillColor = color;
       this.current.patternFill = false;
@@ -1355,14 +1614,20 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       var pattern = (0, _pattern_helper.getShadingPatternFromIR)(patternIR);
       ctx.fillStyle = pattern.getPattern(ctx, this, true);
       var inv = ctx.mozCurrentTransformInverse;
+
       if (inv) {
         var canvas = ctx.canvas;
         var width = canvas.width;
         var height = canvas.height;
+
         var bl = _util.Util.applyTransform([0, 0], inv);
+
         var br = _util.Util.applyTransform([0, height], inv);
+
         var ul = _util.Util.applyTransform([width, 0], inv);
+
         var ur = _util.Util.applyTransform([width, height], inv);
+
         var x0 = Math.min(bl[0], br[0], ul[0], ur[0]);
         var y0 = Math.min(bl[1], br[1], ul[1], ur[1]);
         var x1 = Math.max(bl[0], br[0], ul[0], ur[0]);
@@ -1371,6 +1636,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       } else {
         this.ctx.fillRect(-1e10, -1e10, 2e10, 2e10);
       }
+
       this.restore();
     },
     beginInlineImage: function CanvasGraphics_beginInlineImage() {
@@ -1382,11 +1648,14 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
     paintFormXObjectBegin: function CanvasGraphics_paintFormXObjectBegin(matrix, bbox) {
       this.save();
       this.baseTransformStack.push(this.baseTransform);
+
       if (Array.isArray(matrix) && matrix.length === 6) {
         this.transform.apply(this, matrix);
       }
+
       this.baseTransform = this.ctx.mozCurrentTransform;
-      if (Array.isArray(bbox) && bbox.length === 4) {
+
+      if (bbox) {
         var width = bbox[2] - bbox[0];
         var height = bbox[3] - bbox[1];
         this.ctx.rect(bbox[0], bbox[1], width, height);
@@ -1401,20 +1670,27 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
     beginGroup: function CanvasGraphics_beginGroup(group) {
       this.save();
       var currentCtx = this.ctx;
+
       if (!group.isolated) {
         (0, _util.info)('TODO: Support non-isolated groups.');
       }
+
       if (group.knockout) {
         (0, _util.warn)('Knockout groups not supported.');
       }
+
       var currentTransform = currentCtx.mozCurrentTransform;
+
       if (group.matrix) {
         currentCtx.transform.apply(currentCtx, group.matrix);
       }
+
       if (!group.bbox) {
         throw new Error('Bounding box is required.');
       }
+
       var bounds = _util.Util.getAxialAlignedBoundingBox(group.bbox, currentCtx.mozCurrentTransform);
+
       var canvasBounds = [0, 0, currentCtx.canvas.width, currentCtx.canvas.height];
       bounds = _util.Util.intersect(bounds, canvasBounds) || [0, 0, 0, 0];
       var offsetX = Math.floor(bounds[0]);
@@ -1423,23 +1699,29 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       var drawnHeight = Math.max(Math.ceil(bounds[3]) - offsetY, 1);
       var scaleX = 1,
           scaleY = 1;
+
       if (drawnWidth > MAX_GROUP_SIZE) {
         scaleX = drawnWidth / MAX_GROUP_SIZE;
         drawnWidth = MAX_GROUP_SIZE;
       }
+
       if (drawnHeight > MAX_GROUP_SIZE) {
         scaleY = drawnHeight / MAX_GROUP_SIZE;
         drawnHeight = MAX_GROUP_SIZE;
       }
+
       var cacheId = 'groupAt' + this.groupLevel;
+
       if (group.smask) {
         cacheId += '_smask_' + this.smaskCounter++ % 2;
       }
+
       var scratchCanvas = this.cachedCanvases.getCanvas(cacheId, drawnWidth, drawnHeight, true);
       var groupCtx = scratchCanvas.context;
       groupCtx.scale(1 / scaleX, 1 / scaleY);
       groupCtx.translate(-offsetX, -offsetY);
       groupCtx.transform.apply(groupCtx, currentTransform);
+
       if (group.smask) {
         this.smaskStack.push({
           canvas: scratchCanvas.canvas,
@@ -1458,6 +1740,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
         currentCtx.translate(offsetX, offsetY);
         currentCtx.scale(scaleX, scaleY);
       }
+
       copyCtxState(currentCtx, groupCtx);
       this.ctx = groupCtx;
       this.setGState([['BM', 'source-over'], ['ca', 1], ['CA', 1]]);
@@ -1469,20 +1752,24 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       this.groupLevel--;
       var groupCtx = this.ctx;
       this.ctx = this.groupStack.pop();
+
       if (this.ctx.imageSmoothingEnabled !== undefined) {
         this.ctx.imageSmoothingEnabled = false;
       } else {
         this.ctx.mozImageSmoothingEnabled = false;
       }
+
       if (group.smask) {
         this.tempSMask = this.smaskStack.pop();
       } else {
         this.ctx.drawImage(groupCtx.canvas, 0, 0);
       }
+
       this.restore();
     },
     beginAnnotations: function CanvasGraphics_beginAnnotations() {
       this.save();
+
       if (this.baseTransform) {
         this.ctx.setTransform.apply(this.ctx, this.baseTransform);
       }
@@ -1494,6 +1781,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       this.save();
       resetCtxToDefault(this.ctx);
       this.current = new CanvasExtraState();
+
       if (Array.isArray(rect) && rect.length === 4) {
         var width = rect[2] - rect[0];
         var height = rect[3] - rect[1];
@@ -1501,6 +1789,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
         this.clip();
         this.endPath();
       }
+
       this.transform.apply(this, transform);
       this.transform.apply(this, matrix);
     },
@@ -1508,15 +1797,18 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       this.restore();
     },
     paintJpegXObject: function CanvasGraphics_paintJpegXObject(objId, w, h) {
-      var domImage = this.objs.get(objId);
+      var domImage = this.processingType3 ? this.commonObjs.get(objId) : this.objs.get(objId);
+
       if (!domImage) {
         (0, _util.warn)('Dependent image isn\'t ready yet');
         return;
       }
+
       this.save();
       var ctx = this.ctx;
       ctx.scale(1 / w, -1 / h);
       ctx.drawImage(domImage, 0, 0, domImage.width, domImage.height, 0, -h, w, h);
+
       if (this.imageLayer) {
         var currentTransform = ctx.mozCurrentTransformInverse;
         var position = this.getCanvasPosition(0, 0);
@@ -1528,6 +1820,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
           height: h / currentTransform[3]
         });
       }
+
       this.restore();
     },
     paintImageMaskXObject: function CanvasGraphics_paintImageMaskXObject(img) {
@@ -1537,6 +1830,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       var fillColor = this.current.fillColor;
       var isPatternFill = this.current.patternFill;
       var glyph = this.processingType3;
+
       if (COMPILE_TYPE3_GLYPHS && glyph && glyph.compiled === undefined) {
         if (width <= MAX_SIZE_TO_COMPILE && height <= MAX_SIZE_TO_COMPILE) {
           glyph.compiled = compileType3Glyph({
@@ -1548,10 +1842,12 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
           glyph.compiled = null;
         }
       }
+
       if (glyph && glyph.compiled) {
         glyph.compiled(ctx);
         return;
       }
+
       var maskCanvas = this.cachedCanvases.getCanvas('maskCanvas', width, height);
       var maskCtx = maskCanvas.context;
       maskCtx.save();
@@ -1576,6 +1872,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       maskCtx.fillRect(0, 0, width, height);
       maskCtx.restore();
       var ctx = this.ctx;
+
       for (var i = 0, ii = positions.length; i < ii; i += 2) {
         ctx.save();
         ctx.transform(scaleX, 0, 0, scaleY, positions[i], positions[i + 1]);
@@ -1588,6 +1885,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       var ctx = this.ctx;
       var fillColor = this.current.fillColor;
       var isPatternFill = this.current.patternFill;
+
       for (var i = 0, ii = images.length; i < ii; i++) {
         var image = images[i];
         var width = image.width,
@@ -1608,22 +1906,27 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       }
     },
     paintImageXObject: function CanvasGraphics_paintImageXObject(objId) {
-      var imgData = this.objs.get(objId);
+      var imgData = this.processingType3 ? this.commonObjs.get(objId) : this.objs.get(objId);
+
       if (!imgData) {
         (0, _util.warn)('Dependent image isn\'t ready yet');
         return;
       }
+
       this.paintInlineImageXObject(imgData);
     },
     paintImageXObjectRepeat: function CanvasGraphics_paintImageXObjectRepeat(objId, scaleX, scaleY, positions) {
-      var imgData = this.objs.get(objId);
+      var imgData = this.processingType3 ? this.commonObjs.get(objId) : this.objs.get(objId);
+
       if (!imgData) {
         (0, _util.warn)('Dependent image isn\'t ready yet');
         return;
       }
+
       var width = imgData.width;
       var height = imgData.height;
       var map = [];
+
       for (var i = 0, ii = positions.length; i < ii; i += 2) {
         map.push({
           transform: [scaleX, 0, 0, scaleY, positions[i], positions[i + 1]],
@@ -1633,6 +1936,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
           h: height
         });
       }
+
       this.paintInlineImageXObjectGroup(imgData, map);
     },
     paintInlineImageXObject: function CanvasGraphics_paintInlineImageXObject(imgData) {
@@ -1649,6 +1953,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
           d = currentTransform[3];
       var heightScale = Math.max(Math.sqrt(c * c + d * d), 1);
       var imgToPaint, tmpCanvas;
+
       if (typeof HTMLElement === 'function' && imgData instanceof HTMLElement || !imgData.data) {
         imgToPaint = imgData;
       } else {
@@ -1657,20 +1962,25 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
         putBinaryImageData(tmpCtx, imgData);
         imgToPaint = tmpCanvas.canvas;
       }
+
       var paintWidth = width,
           paintHeight = height;
       var tmpCanvasId = 'prescale1';
+
       while (widthScale > 2 && paintWidth > 1 || heightScale > 2 && paintHeight > 1) {
         var newWidth = paintWidth,
             newHeight = paintHeight;
+
         if (widthScale > 2 && paintWidth > 1) {
           newWidth = Math.ceil(paintWidth / 2);
           widthScale /= paintWidth / newWidth;
         }
+
         if (heightScale > 2 && paintHeight > 1) {
           newHeight = Math.ceil(paintHeight / 2);
           heightScale /= paintHeight / newHeight;
         }
+
         tmpCanvas = this.cachedCanvases.getCanvas(tmpCanvasId, newWidth, newHeight);
         tmpCtx = tmpCanvas.context;
         tmpCtx.clearRect(0, 0, newWidth, newHeight);
@@ -1680,7 +1990,9 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
         paintHeight = newHeight;
         tmpCanvasId = tmpCanvasId === 'prescale1' ? 'prescale2' : 'prescale1';
       }
+
       ctx.drawImage(imgToPaint, 0, 0, paintWidth, paintHeight, 0, -height, width, height);
+
       if (this.imageLayer) {
         var position = this.getCanvasPosition(0, -height);
         this.imageLayer.appendImage({
@@ -1691,6 +2003,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
           height: height / currentTransform[3]
         });
       }
+
       this.restore();
     },
     paintInlineImageXObjectGroup: function CanvasGraphics_paintInlineImageXObjectGroup(imgData, map) {
@@ -1700,12 +2013,14 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
       var tmpCanvas = this.cachedCanvases.getCanvas('inlineImage', w, h);
       var tmpCtx = tmpCanvas.context;
       putBinaryImageData(tmpCtx, imgData);
+
       for (var i = 0, ii = map.length; i < ii; i++) {
         var entry = map[i];
         ctx.save();
         ctx.transform.apply(ctx, entry.transform);
         ctx.scale(1, -1);
         ctx.drawImage(tmpCanvas.canvas, entry.x, entry.y, entry.w, entry.h, 0, -1, 1, 1);
+
         if (this.imageLayer) {
           var position = this.getCanvasPosition(entry.x, entry.y);
           this.imageLayer.appendImage({
@@ -1716,6 +2031,7 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
             height: h
           });
         }
+
         ctx.restore();
       }
     },
@@ -1734,33 +2050,38 @@ var CanvasGraphics = function CanvasGraphicsClosure() {
     endCompat: function CanvasGraphics_endCompat() {},
     consumePath: function CanvasGraphics_consumePath() {
       var ctx = this.ctx;
+
       if (this.pendingClip) {
         if (this.pendingClip === EO_CLIP) {
           ctx.clip('evenodd');
         } else {
           ctx.clip();
         }
+
         this.pendingClip = null;
       }
+
       ctx.beginPath();
     },
-    getSinglePixelWidth: function CanvasGraphics_getSinglePixelWidth(scale) {
-      if (this.cachedGetSinglePixelWidth === null) {
-        this.ctx.save();
+    getSinglePixelWidth: function getSinglePixelWidth(scale) {
+      if (this._cachedGetSinglePixelWidth === null) {
         var inverse = this.ctx.mozCurrentTransformInverse;
-        this.ctx.restore();
-        this.cachedGetSinglePixelWidth = Math.sqrt(Math.max(inverse[0] * inverse[0] + inverse[1] * inverse[1], inverse[2] * inverse[2] + inverse[3] * inverse[3]));
+        this._cachedGetSinglePixelWidth = Math.sqrt(Math.max(inverse[0] * inverse[0] + inverse[1] * inverse[1], inverse[2] * inverse[2] + inverse[3] * inverse[3]));
       }
-      return this.cachedGetSinglePixelWidth;
+
+      return this._cachedGetSinglePixelWidth;
     },
     getCanvasPosition: function CanvasGraphics_getCanvasPosition(x, y) {
       var transform = this.ctx.mozCurrentTransform;
       return [transform[0] * x + transform[2] * y + transform[4], transform[1] * x + transform[3] * y + transform[5]];
     }
   };
+
   for (var op in _util.OPS) {
     CanvasGraphics.prototype[_util.OPS[op]] = CanvasGraphics.prototype[op];
   }
+
   return CanvasGraphics;
 }();
+
 exports.CanvasGraphics = CanvasGraphics;