pdfjs-dist 2.0.487 → 2.1.266

package/lib/display/svg.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 2018 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,38 +19,41 @@
  * @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.SVGGraphics = undefined;
+exports.SVGGraphics = void 0;
 
-var _util = require('../shared/util');
+var _util = require("../shared/util");
 
-var _dom_utils = require('./dom_utils');
+var _dom_utils = require("./dom_utils");
 
-var _is_node = require('../shared/is_node');
-
-var _is_node2 = _interopRequireDefault(_is_node);
+var _is_node = _interopRequireDefault(require("../shared/is_node"));
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
 var SVGGraphics = function SVGGraphics() {
   throw new Error('Not implemented: SVGGraphics');
 };
+
+exports.SVGGraphics = SVGGraphics;
 {
   var SVG_DEFAULTS = {
     fontStyle: 'normal',
     fontWeight: 'normal',
     fillColor: '#000000'
   };
+
   var convertImgDataToPng = function convertImgDataToPngClosure() {
     var PNG_HEADER = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
     var CHUNK_WRAPPER_SIZE = 12;
     var crcTable = new Int32Array(256);
+
     for (var i = 0; i < 256; i++) {
       var c = i;
+
       for (var h = 0; h < 8; h++) {
         if (c & 1) {
           c = 0xedB88320 ^ c >> 1 & 0x7fffffff;
@@ -58,17 +61,22 @@ var SVGGraphics = function SVGGraphics() {
           c = c >> 1 & 0x7fffffff;
         }
       }
+
       crcTable[i] = c;
     }
+
     function crc32(data, start, end) {
       var crc = -1;
+
       for (var i = start; i < end; i++) {
         var a = (crc ^ data[i]) & 0xff;
         var b = crcTable[a];
         crc = crc >>> 8 ^ b;
       }
+
       return crc ^ -1;
     }
+
     function writePngChunk(type, body, data, offset) {
       var p = offset;
       var len = body.length;
@@ -90,33 +98,45 @@ var SVGGraphics = function SVGGraphics() {
       data[p + 2] = crc >> 8 & 0xff;
       data[p + 3] = crc & 0xff;
     }
+
     function adler32(data, start, end) {
       var a = 1;
       var b = 0;
+
       for (var i = start; i < end; ++i) {
         a = (a + (data[i] & 0xff)) % 65521;
         b = (b + a) % 65521;
       }
+
       return b << 16 | a;
     }
+
     function deflateSync(literals) {
-      if (!(0, _is_node2.default)()) {
+      if (!(0, _is_node.default)()) {
         return deflateSyncUncompressed(literals);
       }
+
       try {
         var input;
+
         if (parseInt(process.versions.node) >= 8) {
           input = literals;
         } else {
           input = new Buffer(literals);
         }
-        var output = require('zlib').deflateSync(input, { level: 9 });
+
+        var output = require('zlib').deflateSync(input, {
+          level: 9
+        });
+
         return output instanceof Uint8Array ? output : new Uint8Array(output);
       } catch (e) {
         (0, _util.warn)('Not compressing PNG because zlib.deflateSync is unavailable: ' + e);
       }
+
       return deflateSyncUncompressed(literals);
     }
+
     function deflateSyncUncompressed(literals) {
       var len = literals.length;
       var maxBlockLength = 0xFFFF;
@@ -126,6 +146,7 @@ var SVGGraphics = function SVGGraphics() {
       idat[pi++] = 0x78;
       idat[pi++] = 0x9c;
       var pos = 0;
+
       while (len > maxBlockLength) {
         idat[pi++] = 0x00;
         idat[pi++] = 0xff;
@@ -137,6 +158,7 @@ var SVGGraphics = function SVGGraphics() {
         pos += maxBlockLength;
         len -= maxBlockLength;
       }
+
       idat[pi++] = 0x01;
       idat[pi++] = len & 0xff;
       idat[pi++] = len >> 8 & 0xff;
@@ -151,49 +173,60 @@ var SVGGraphics = function SVGGraphics() {
       idat[pi++] = adler & 0xff;
       return idat;
     }
+
     function encode(imgData, kind, forceDataSchema, isMask) {
       var width = imgData.width;
       var height = imgData.height;
       var bitDepth, colorType, lineSize;
       var bytes = imgData.data;
+
       switch (kind) {
         case _util.ImageKind.GRAYSCALE_1BPP:
           colorType = 0;
           bitDepth = 1;
           lineSize = width + 7 >> 3;
           break;
+
         case _util.ImageKind.RGB_24BPP:
           colorType = 2;
           bitDepth = 8;
           lineSize = width * 3;
           break;
+
         case _util.ImageKind.RGBA_32BPP:
           colorType = 6;
           bitDepth = 8;
           lineSize = width * 4;
           break;
+
         default:
           throw new Error('invalid format');
       }
+
       var literals = new Uint8Array((1 + lineSize) * height);
       var offsetLiterals = 0,
           offsetBytes = 0;
       var y, i;
+
       for (y = 0; y < height; ++y) {
         literals[offsetLiterals++] = 0;
         literals.set(bytes.subarray(offsetBytes, offsetBytes + lineSize), offsetLiterals);
         offsetBytes += lineSize;
         offsetLiterals += lineSize;
       }
+
       if (kind === _util.ImageKind.GRAYSCALE_1BPP && isMask) {
         offsetLiterals = 0;
+
         for (y = 0; y < height; y++) {
           offsetLiterals++;
+
           for (i = 0; i < lineSize; i++) {
             literals[offsetLiterals++] ^= 0xFF;
           }
         }
       }
+
       var ihdr = new Uint8Array([width >> 24 & 0xff, width >> 16 & 0xff, width >> 8 & 0xff, width & 0xff, height >> 24 & 0xff, height >> 16 & 0xff, height >> 8 & 0xff, height & 0xff, bitDepth, colorType, 0x00, 0x00, 0x00]);
       var idat = deflateSync(literals);
       var pngLength = PNG_HEADER.length + CHUNK_WRAPPER_SIZE * 3 + ihdr.length + idat.length;
@@ -208,11 +241,13 @@ var SVGGraphics = function SVGGraphics() {
       writePngChunk('IEND', new Uint8Array(0), data, offset);
       return (0, _util.createObjectURL)(data, 'image/png', forceDataSchema);
     }
+
     return function convertImgDataToPng(imgData, forceDataSchema, isMask) {
       var kind = imgData.kind === undefined ? _util.ImageKind.GRAYSCALE_1BPP : imgData.kind;
       return encode(imgData, kind, forceDataSchema, isMask);
     };
   }();
+
   var SVGExtraState = function SVGExtraStateClosure() {
     function SVGExtraState() {
       this.fontSizeScale = 1;
@@ -221,6 +256,7 @@ var SVGGraphics = function SVGGraphics() {
       this.textMatrix = _util.IDENTITY_MATRIX;
       this.fontMatrix = _util.FONT_IDENTITY_MATRIX;
       this.leading = 0;
+      this.textRenderingMode = _util.TextRenderingMode.FILL;
       this.x = 0;
       this.y = 0;
       this.lineX = 0;
@@ -244,6 +280,7 @@ var SVGGraphics = function SVGGraphics() {
       this.clipGroup = null;
       this.maskId = '';
     }
+
     SVGExtraState.prototype = {
       clone: function SVGExtraState_clone() {
         return Object.create(this);
@@ -255,11 +292,13 @@ var SVGGraphics = function SVGGraphics() {
     };
     return SVGExtraState;
   }();
+
   exports.SVGGraphics = SVGGraphics = function SVGGraphicsClosure() {
     function opListToTree(opList) {
       var opTree = [];
       var tmp = [];
       var opListLen = opList.length;
+
       for (var x = 0; x < opListLen; x++) {
         if (opList[x].fn === 'save') {
           opTree.push({
@@ -271,36 +310,46 @@ var SVGGraphics = function SVGGraphics() {
           opTree = opTree[opTree.length - 1].items;
           continue;
         }
+
         if (opList[x].fn === 'restore') {
           opTree = tmp.pop();
         } else {
           opTree.push(opList[x]);
         }
       }
+
       return opTree;
     }
+
     function pf(value) {
       if (Number.isInteger(value)) {
         return value.toString();
       }
+
       var s = value.toFixed(10);
       var i = s.length - 1;
+
       if (s[i] !== '0') {
         return s;
       }
+
       do {
         i--;
       } while (s[i] === '0');
-      return s.substr(0, s[i] === '.' ? i : i + 1);
+
+      return s.substring(0, s[i] === '.' ? i : i + 1);
     }
+
     function pm(m) {
       if (m[4] === 0 && m[5] === 0) {
         if (m[1] === 0 && m[2] === 0) {
           if (m[0] === 1 && m[3] === 1) {
             return '';
           }
+
           return 'scale(' + pf(m[0]) + ' ' + pf(m[3]) + ')';
         }
+
         if (m[0] === m[3] && m[1] === -m[2]) {
           var a = Math.acos(m[0]) * 180 / Math.PI;
           return 'rotate(' + pf(a) + ')';
@@ -310,8 +359,10 @@ var SVGGraphics = function SVGGraphics() {
           return 'translate(' + pf(m[4]) + ' ' + pf(m[5]) + ')';
         }
       }
+
       return 'matrix(' + pf(m[0]) + ' ' + pf(m[1]) + ' ' + pf(m[2]) + ' ' + pf(m[3]) + ' ' + pf(m[4]) + ' ' + pf(m[5]) + ')';
     }
+
     function SVGGraphics(commonObjs, objs, forceDataSchema) {
       this.svgFactory = new _dom_utils.DOMSVGFactory();
       this.current = new SVGExtraState();
@@ -327,6 +378,7 @@ var SVGGraphics = function SVGGraphics() {
       this.cssStyle = null;
       this.forceDataSchema = !!forceDataSchema;
     }
+
     var XML_NS = 'http://www.w3.org/XML/1998/namespace';
     var XLINK_NS = 'http://www.w3.org/1999/xlink';
     var LINE_CAP_STYLES = ['butt', 'round', 'square'];
@@ -357,13 +409,16 @@ var SVGGraphics = function SVGGraphics() {
         var fnArray = operatorList.fnArray;
         var fnArrayLen = fnArray.length;
         var argsArray = operatorList.argsArray;
+
         for (var i = 0; i < fnArrayLen; i++) {
           if (_util.OPS.dependency === fnArray[i]) {
             var deps = argsArray[i];
+
             for (var n = 0, nn = deps.length; n < nn; n++) {
               var obj = deps[n];
               var common = obj.substring(0, 2) === 'g_';
               var promise;
+
               if (common) {
                 promise = new Promise(function (resolve) {
                   _this.commonObjs.get(obj, resolve);
@@ -373,10 +428,12 @@ var SVGGraphics = function SVGGraphics() {
                   _this.objs.get(obj, resolve);
                 });
               }
+
               this.current.dependencies.push(promise);
             }
           }
         }
+
         return Promise.all(this.current.dependencies);
       },
       transform: function SVGGraphics_transform(a, b, c, d, e, f) {
@@ -388,11 +445,16 @@ var SVGGraphics = function SVGGraphics() {
         var _this2 = this;
 
         this.viewport = viewport;
+
         var svgElement = this._initialize(viewport);
+
         return this.loadDependencies(operatorList).then(function () {
           _this2.transformMatrix = _util.IDENTITY_MATRIX;
+
           var opTree = _this2.convertOpList(operatorList);
+
           _this2.executeOpTree(opTree);
+
           return svgElement;
         });
       },
@@ -402,9 +464,11 @@ var SVGGraphics = function SVGGraphics() {
         var fnArrayLen = fnArray.length;
         var REVOPS = [];
         var opList = [];
+
         for (var op in _util.OPS) {
           REVOPS[_util.OPS[op]] = op;
         }
+
         for (var x = 0; x < fnArrayLen; x++) {
           var fnId = fnArray[x];
           opList.push({
@@ -413,149 +477,201 @@ var SVGGraphics = function SVGGraphics() {
             'args': argsArray[x]
           });
         }
+
         return opListToTree(opList);
       },
       executeOpTree: function SVGGraphics_executeOpTree(opTree) {
         var opTreeLen = opTree.length;
+
         for (var x = 0; x < opTreeLen; x++) {
           var fn = opTree[x].fn;
           var fnId = opTree[x].fnId;
           var args = opTree[x].args;
+
           switch (fnId | 0) {
             case _util.OPS.beginText:
               this.beginText();
               break;
+
             case _util.OPS.dependency:
               break;
+
             case _util.OPS.setLeading:
               this.setLeading(args);
               break;
+
             case _util.OPS.setLeadingMoveText:
               this.setLeadingMoveText(args[0], args[1]);
               break;
+
             case _util.OPS.setFont:
               this.setFont(args);
               break;
+
             case _util.OPS.showText:
               this.showText(args[0]);
               break;
+
             case _util.OPS.showSpacedText:
               this.showText(args[0]);
               break;
+
             case _util.OPS.endText:
               this.endText();
               break;
+
             case _util.OPS.moveText:
               this.moveText(args[0], args[1]);
               break;
+
             case _util.OPS.setCharSpacing:
               this.setCharSpacing(args[0]);
               break;
+
             case _util.OPS.setWordSpacing:
               this.setWordSpacing(args[0]);
               break;
+
             case _util.OPS.setHScale:
               this.setHScale(args[0]);
               break;
+
             case _util.OPS.setTextMatrix:
               this.setTextMatrix(args[0], args[1], args[2], args[3], args[4], args[5]);
               break;
+
             case _util.OPS.setTextRise:
               this.setTextRise(args[0]);
               break;
+
+            case _util.OPS.setTextRenderingMode:
+              this.setTextRenderingMode(args[0]);
+              break;
+
             case _util.OPS.setLineWidth:
               this.setLineWidth(args[0]);
               break;
+
             case _util.OPS.setLineJoin:
               this.setLineJoin(args[0]);
               break;
+
             case _util.OPS.setLineCap:
               this.setLineCap(args[0]);
               break;
+
             case _util.OPS.setMiterLimit:
               this.setMiterLimit(args[0]);
               break;
+
             case _util.OPS.setFillRGBColor:
               this.setFillRGBColor(args[0], args[1], args[2]);
               break;
+
             case _util.OPS.setStrokeRGBColor:
               this.setStrokeRGBColor(args[0], args[1], args[2]);
               break;
+
             case _util.OPS.setDash:
               this.setDash(args[0], args[1]);
               break;
+
             case _util.OPS.setGState:
               this.setGState(args[0]);
               break;
+
             case _util.OPS.fill:
               this.fill();
               break;
+
             case _util.OPS.eoFill:
               this.eoFill();
               break;
+
             case _util.OPS.stroke:
               this.stroke();
               break;
+
             case _util.OPS.fillStroke:
               this.fillStroke();
               break;
+
             case _util.OPS.eoFillStroke:
               this.eoFillStroke();
               break;
+
             case _util.OPS.clip:
               this.clip('nonzero');
               break;
+
             case _util.OPS.eoClip:
               this.clip('evenodd');
               break;
+
             case _util.OPS.paintSolidColorImageMask:
               this.paintSolidColorImageMask();
               break;
+
             case _util.OPS.paintJpegXObject:
               this.paintJpegXObject(args[0], args[1], args[2]);
               break;
+
             case _util.OPS.paintImageXObject:
               this.paintImageXObject(args[0]);
               break;
+
             case _util.OPS.paintInlineImageXObject:
               this.paintInlineImageXObject(args[0]);
               break;
+
             case _util.OPS.paintImageMaskXObject:
               this.paintImageMaskXObject(args[0]);
               break;
+
             case _util.OPS.paintFormXObjectBegin:
               this.paintFormXObjectBegin(args[0], args[1]);
               break;
+
             case _util.OPS.paintFormXObjectEnd:
               this.paintFormXObjectEnd();
               break;
+
             case _util.OPS.closePath:
               this.closePath();
               break;
+
             case _util.OPS.closeStroke:
               this.closeStroke();
               break;
+
             case _util.OPS.closeFillStroke:
               this.closeFillStroke();
               break;
+
             case _util.OPS.closeEOFillStroke:
               this.closeEOFillStroke();
               break;
+
             case _util.OPS.nextLine:
               this.nextLine();
               break;
+
             case _util.OPS.transform:
               this.transform(args[0], args[1], args[2], args[3], args[4], args[5]);
               break;
+
             case _util.OPS.constructPath:
               this.constructPath(args[0], args[1]);
               break;
+
             case _util.OPS.endPath:
               this.endPath();
               break;
+
             case 92:
               this.group(opTree[x].items);
               break;
+
             default:
               (0, _util.warn)('Unimplemented operator ' + fn);
               break;
@@ -608,9 +724,11 @@ var SVGGraphics = function SVGGraphics() {
         var current = this.current;
         var font = current.font;
         var fontSize = current.fontSize;
+
         if (fontSize === 0) {
           return;
         }
+
         var charSpacing = current.charSpacing;
         var wordSpacing = current.wordSpacing;
         var fontDirection = current.fontDirection;
@@ -620,8 +738,10 @@ var SVGGraphics = function SVGGraphics() {
         var widthAdvanceScale = fontSize * current.fontMatrix[0];
         var x = 0,
             i;
+
         for (i = 0; i < glyphsLength; ++i) {
           var glyph = glyphs[i];
+
           if (glyph === null) {
             x += fontDirection * wordSpacing;
             continue;
@@ -629,45 +749,73 @@ var SVGGraphics = function SVGGraphics() {
             x += -glyph * fontSize * 0.001;
             continue;
           }
+
           var width = glyph.width;
           var character = glyph.fontChar;
           var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
           var charWidth = width * widthAdvanceScale + spacing * fontDirection;
+
           if (!glyph.isInFont && !font.missingFile) {
             x += charWidth;
             continue;
           }
+
           current.xcoords.push(current.x + x * textHScale);
           current.tspan.textContent += character;
           x += charWidth;
         }
+
         if (vertical) {
           current.y -= x * textHScale;
         } else {
           current.x += x * textHScale;
         }
+
         current.tspan.setAttributeNS(null, 'x', current.xcoords.map(pf).join(' '));
         current.tspan.setAttributeNS(null, 'y', pf(-current.y));
         current.tspan.setAttributeNS(null, 'font-family', current.fontFamily);
         current.tspan.setAttributeNS(null, 'font-size', pf(current.fontSize) + 'px');
+
         if (current.fontStyle !== SVG_DEFAULTS.fontStyle) {
           current.tspan.setAttributeNS(null, 'font-style', current.fontStyle);
         }
+
         if (current.fontWeight !== SVG_DEFAULTS.fontWeight) {
           current.tspan.setAttributeNS(null, 'font-weight', current.fontWeight);
         }
-        if (current.fillColor !== SVG_DEFAULTS.fillColor) {
-          current.tspan.setAttributeNS(null, 'fill', current.fillColor);
+
+        var fillStrokeMode = current.textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK;
+
+        if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
+          if (current.fillColor !== SVG_DEFAULTS.fillColor) {
+            current.tspan.setAttributeNS(null, 'fill', current.fillColor);
+          }
+
+          if (current.fillAlpha < 1) {
+            current.tspan.setAttributeNS(null, 'fill-opacity', current.fillAlpha);
+          }
+        } else if (current.textRenderingMode === _util.TextRenderingMode.ADD_TO_PATH) {
+          current.tspan.setAttributeNS(null, 'fill', 'transparent');
+        } else {
+          current.tspan.setAttributeNS(null, 'fill', 'none');
         }
+
+        if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
+          this._setStrokeAttributes(current.tspan);
+        }
+
         var textMatrix = current.textMatrix;
+
         if (current.textRise !== 0) {
           textMatrix = textMatrix.slice();
           textMatrix[5] += current.textRise;
         }
+
         current.txtElement.setAttributeNS(null, 'transform', pm(textMatrix) + ' scale(1, -1)');
         current.txtElement.setAttributeNS(XML_NS, 'xml:space', 'preserve');
         current.txtElement.appendChild(current.tspan);
         current.txtgrp.appendChild(current.txtElement);
+
         this._ensureTransformGroup().appendChild(current.txtElement);
       },
       setLeadingMoveText: function SVGGraphics_setLeadingMoveText(x, y) {
@@ -680,6 +828,7 @@ var SVGGraphics = function SVGGraphics() {
           this.cssStyle.setAttributeNS(null, 'type', 'text/css');
           this.defs.appendChild(this.cssStyle);
         }
+
         var url = (0, _util.createObjectURL)(fontObj.data, fontObj.mimetype, this.forceDataSchema);
         this.cssStyle.textContent += '@font-face { font-family: "' + fontObj.loadedName + '";' + ' src: url(' + url + '); }\n';
       },
@@ -688,19 +837,23 @@ var SVGGraphics = function SVGGraphics() {
         var fontObj = this.commonObjs.get(details[0]);
         var size = details[1];
         this.current.font = fontObj;
+
         if (this.embedFonts && fontObj.data && !this.embeddedFonts[fontObj.loadedName]) {
           this.addFontStyle(fontObj);
           this.embeddedFonts[fontObj.loadedName] = fontObj;
         }
+
         current.fontMatrix = fontObj.fontMatrix ? fontObj.fontMatrix : _util.FONT_IDENTITY_MATRIX;
         var bold = fontObj.black ? fontObj.bold ? 'bolder' : 'bold' : fontObj.bold ? 'bold' : 'normal';
         var italic = fontObj.italic ? 'italic' : 'normal';
+
         if (size < 0) {
           size = -size;
           current.fontDirection = -1;
         } else {
           current.fontDirection = 1;
         }
+
         current.fontSize = size;
         current.fontFamily = fontObj.loadedName;
         current.fontWeight = bold;
@@ -709,9 +862,19 @@ var SVGGraphics = function SVGGraphics() {
         current.tspan.setAttributeNS(null, 'y', pf(-current.y));
         current.xcoords = [];
       },
-      endText: function SVGGraphics_endText() {},
+      endText: function endText() {
+        var current = this.current;
+
+        if (current.textRenderingMode & _util.TextRenderingMode.ADD_TO_PATH_FLAG && current.txtElement && current.txtElement.hasChildNodes()) {
+          current.element = current.txtElement;
+          this.clip('nonzero');
+          this.endPath();
+        }
+      },
       setLineWidth: function SVGGraphics_setLineWidth(width) {
-        this.current.lineWidth = width;
+        if (width > 0) {
+          this.current.lineWidth = width;
+        }
       },
       setLineCap: function SVGGraphics_setLineCap(style) {
         this.current.lineCap = LINE_CAP_STYLES[style];
@@ -727,6 +890,7 @@ var SVGGraphics = function SVGGraphics() {
       },
       setStrokeRGBColor: function SVGGraphics_setStrokeRGBColor(r, g, b) {
         var color = _util.Util.makeCssRgb(r, g, b);
+
         this.current.strokeColor = color;
       },
       setFillAlpha: function SVGGraphics_setFillAlpha(fillAlpha) {
@@ -734,6 +898,7 @@ var SVGGraphics = function SVGGraphics() {
       },
       setFillRGBColor: function SVGGraphics_setFillRGBColor(r, g, b) {
         var color = _util.Util.makeCssRgb(r, g, b);
+
         this.current.fillColor = color;
         this.current.tspan = this.svgFactory.createElement('svg:tspan');
         this.current.xcoords = [];
@@ -749,6 +914,7 @@ var SVGGraphics = function SVGGraphics() {
         current.path = this.svgFactory.createElement('svg:path');
         var d = [];
         var opLength = ops.length;
+
         for (var i = 0, j = 0; i < opLength; i++) {
           switch (ops[i] | 0) {
             case _util.OPS.rectangle:
@@ -760,42 +926,51 @@ var SVGGraphics = function SVGGraphics() {
               var yh = y + height;
               d.push('M', pf(x), pf(y), 'L', pf(xw), pf(y), 'L', pf(xw), pf(yh), 'L', pf(x), pf(yh), 'Z');
               break;
+
             case _util.OPS.moveTo:
               x = args[j++];
               y = args[j++];
               d.push('M', pf(x), pf(y));
               break;
+
             case _util.OPS.lineTo:
               x = args[j++];
               y = args[j++];
               d.push('L', pf(x), pf(y));
               break;
+
             case _util.OPS.curveTo:
               x = args[j + 4];
               y = args[j + 5];
               d.push('C', pf(args[j]), pf(args[j + 1]), pf(args[j + 2]), pf(args[j + 3]), pf(x), pf(y));
               j += 6;
               break;
+
             case _util.OPS.curveTo2:
               x = args[j + 2];
               y = args[j + 3];
               d.push('C', pf(x), pf(y), pf(args[j]), pf(args[j + 1]), pf(args[j + 2]), pf(args[j + 3]));
               j += 4;
               break;
+
             case _util.OPS.curveTo3:
               x = args[j + 2];
               y = args[j + 3];
               d.push('C', pf(args[j]), pf(args[j + 1]), pf(x), pf(y), pf(x), pf(y));
               j += 4;
               break;
+
             case _util.OPS.closePath:
               d.push('Z');
               break;
           }
         }
+
         current.path.setAttributeNS(null, 'd', d.join(' '));
         current.path.setAttributeNS(null, 'fill', 'none');
+
         this._ensureTransformGroup().appendChild(current.path);
+
         current.element = current.path;
         current.setCurrentPoint(x, y);
       },
@@ -803,27 +978,33 @@ var SVGGraphics = function SVGGraphics() {
         if (!this.pendingClip) {
           return;
         }
+
         var current = this.current;
         var clipId = 'clippath' + clipCount;
         clipCount++;
         var clipPath = this.svgFactory.createElement('svg:clipPath');
         clipPath.setAttributeNS(null, 'id', clipId);
         clipPath.setAttributeNS(null, 'transform', pm(this.transformMatrix));
-        var clipElement = current.element.cloneNode();
+        var clipElement = current.element.cloneNode(true);
+
         if (this.pendingClip === 'evenodd') {
           clipElement.setAttributeNS(null, 'clip-rule', 'evenodd');
         } else {
           clipElement.setAttributeNS(null, 'clip-rule', 'nonzero');
         }
+
         this.pendingClip = null;
         clipPath.appendChild(clipElement);
         this.defs.appendChild(clipPath);
+
         if (current.activeClipUrl) {
           current.clipGroup = null;
           this.extraStack.forEach(function (prev) {
             prev.clipGroup = null;
           });
+          clipPath.setAttributeNS(null, 'clip-path', current.activeClipUrl);
         }
+
         current.activeClipUrl = 'url(#' + clipId + ')';
         this.tgrp = null;
       },
@@ -832,6 +1013,7 @@ var SVGGraphics = function SVGGraphics() {
       },
       closePath: function SVGGraphics_closePath() {
         var current = this.current;
+
         if (current.path) {
           var d = current.path.getAttributeNS(null, 'd');
           d += 'Z';
@@ -844,6 +1026,9 @@ var SVGGraphics = function SVGGraphics() {
       setTextRise: function SVGGraphics_setTextRise(textRise) {
         this.current.textRise = textRise;
       },
+      setTextRenderingMode: function setTextRenderingMode(textRenderingMode) {
+        this.current.textRenderingMode = textRenderingMode;
+      },
       setHScale: function SVGGraphics_setHScale(scale) {
         this.current.textHScale = scale / 100;
       },
@@ -852,31 +1037,40 @@ var SVGGraphics = function SVGGraphics() {
           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 'Font':
               this.setFont(value);
               break;
+
             case 'CA':
               this.setStrokeAlpha(value);
               break;
+
             case 'ca':
               this.setFillAlpha(value);
               break;
+
             default:
               (0, _util.warn)('Unimplemented graphic state ' + key);
               break;
@@ -885,29 +1079,39 @@ var SVGGraphics = function SVGGraphics() {
       },
       fill: function SVGGraphics_fill() {
         var current = this.current;
+
         if (current.element) {
           current.element.setAttributeNS(null, 'fill', current.fillColor);
           current.element.setAttributeNS(null, 'fill-opacity', current.fillAlpha);
+          this.endPath();
         }
       },
       stroke: function SVGGraphics_stroke() {
         var current = this.current;
+
         if (current.element) {
-          current.element.setAttributeNS(null, 'stroke', current.strokeColor);
-          current.element.setAttributeNS(null, 'stroke-opacity', current.strokeAlpha);
-          current.element.setAttributeNS(null, 'stroke-miterlimit', pf(current.miterLimit));
-          current.element.setAttributeNS(null, 'stroke-linecap', current.lineCap);
-          current.element.setAttributeNS(null, 'stroke-linejoin', current.lineJoin);
-          current.element.setAttributeNS(null, 'stroke-width', pf(current.lineWidth) + 'px');
-          current.element.setAttributeNS(null, 'stroke-dasharray', current.dashArray.map(pf).join(' '));
-          current.element.setAttributeNS(null, 'stroke-dashoffset', pf(current.dashPhase) + 'px');
+          this._setStrokeAttributes(current.element);
+
           current.element.setAttributeNS(null, 'fill', 'none');
+          this.endPath();
         }
       },
+      _setStrokeAttributes: function _setStrokeAttributes(element) {
+        var current = this.current;
+        element.setAttributeNS(null, 'stroke', current.strokeColor);
+        element.setAttributeNS(null, 'stroke-opacity', current.strokeAlpha);
+        element.setAttributeNS(null, 'stroke-miterlimit', pf(current.miterLimit));
+        element.setAttributeNS(null, 'stroke-linecap', current.lineCap);
+        element.setAttributeNS(null, 'stroke-linejoin', current.lineJoin);
+        element.setAttributeNS(null, 'stroke-width', pf(current.lineWidth) + 'px');
+        element.setAttributeNS(null, 'stroke-dasharray', current.dashArray.map(pf).join(' '));
+        element.setAttributeNS(null, 'stroke-dashoffset', pf(current.dashPhase) + 'px');
+      },
       eoFill: function SVGGraphics_eoFill() {
         if (this.current.element) {
           this.current.element.setAttributeNS(null, 'fill-rule', 'evenodd');
         }
+
         this.fill();
       },
       fillStroke: function SVGGraphics_fillStroke() {
@@ -918,6 +1122,7 @@ var SVGGraphics = function SVGGraphics() {
         if (this.current.element) {
           this.current.element.setAttributeNS(null, 'fill-rule', 'evenodd');
         }
+
         this.fillStroke();
       },
       closeStroke: function SVGGraphics_closeStroke() {
@@ -932,7 +1137,6 @@ var SVGGraphics = function SVGGraphics() {
         this.closePath();
         this.eoFillStroke();
       },
-
       paintSolidColorImageMask: function SVGGraphics_paintSolidColorImageMask() {
         var current = this.current;
         var rect = this.svgFactory.createElement('svg:rect');
@@ -941,6 +1145,7 @@ var SVGGraphics = function SVGGraphics() {
         rect.setAttributeNS(null, 'width', '1px');
         rect.setAttributeNS(null, 'height', '1px');
         rect.setAttributeNS(null, 'fill', current.fillColor);
+
         this._ensureTransformGroup().appendChild(rect);
       },
       paintJpegXObject: function SVGGraphics_paintJpegXObject(objId, w, h) {
@@ -952,14 +1157,17 @@ var SVGGraphics = function SVGGraphics() {
         imgEl.setAttributeNS(null, 'x', '0');
         imgEl.setAttributeNS(null, 'y', pf(-h));
         imgEl.setAttributeNS(null, 'transform', 'scale(' + pf(1 / w) + ' ' + pf(-1 / h) + ')');
+
         this._ensureTransformGroup().appendChild(imgEl);
       },
       paintImageXObject: function SVGGraphics_paintImageXObject(objId) {
         var imgData = this.objs.get(objId);
+
         if (!imgData) {
           (0, _util.warn)('Dependent image isn\'t ready yet');
           return;
         }
+
         this.paintInlineImageXObject(imgData);
       },
       paintInlineImageXObject: function SVGGraphics_paintInlineImageXObject(imgData, mask) {
@@ -980,6 +1188,7 @@ var SVGGraphics = function SVGGraphics() {
         imgEl.setAttributeNS(null, 'width', pf(width) + 'px');
         imgEl.setAttributeNS(null, 'height', pf(height) + 'px');
         imgEl.setAttributeNS(null, 'transform', 'scale(' + pf(1 / width) + ' ' + pf(-1 / height) + ')');
+
         if (mask) {
           mask.appendChild(imgEl);
         } else {
@@ -1002,14 +1211,17 @@ var SVGGraphics = function SVGGraphics() {
         rect.setAttributeNS(null, 'fill', fillColor);
         rect.setAttributeNS(null, 'mask', 'url(#' + current.maskId + ')');
         this.defs.appendChild(mask);
+
         this._ensureTransformGroup().appendChild(rect);
+
         this.paintInlineImageXObject(imgData, mask);
       },
       paintFormXObjectBegin: function SVGGraphics_paintFormXObjectBegin(matrix, bbox) {
         if (Array.isArray(matrix) && matrix.length === 6) {
           this.transform(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
         }
-        if (Array.isArray(bbox) && bbox.length === 4) {
+
+        if (bbox) {
           var width = bbox[2] - bbox[0];
           var height = bbox[3] - bbox[1];
           var cliprect = this.svgFactory.createElement('svg:rect');
@@ -1034,7 +1246,6 @@ var SVGGraphics = function SVGGraphics() {
         this.svg = rootGroup;
         return svg;
       },
-
       _ensureClipGroup: function SVGGraphics_ensureClipGroup() {
         if (!this.current.clipGroup) {
           var clipGroup = this.svgFactory.createElement('svg:g');
@@ -1042,22 +1253,24 @@ var SVGGraphics = function SVGGraphics() {
           this.svg.appendChild(clipGroup);
           this.current.clipGroup = clipGroup;
         }
+
         return this.current.clipGroup;
       },
       _ensureTransformGroup: function SVGGraphics_ensureTransformGroup() {
         if (!this.tgrp) {
           this.tgrp = this.svgFactory.createElement('svg:g');
           this.tgrp.setAttributeNS(null, 'transform', pm(this.transformMatrix));
+
           if (this.current.activeClipUrl) {
             this._ensureClipGroup().appendChild(this.tgrp);
           } else {
             this.svg.appendChild(this.tgrp);
           }
         }
+
         return this.tgrp;
       }
     };
     return SVGGraphics;
   }();
-}
-exports.SVGGraphics = SVGGraphics;
+}