pdfmake 0.3.0 → 0.3.1

package/js/TextInlines.js

@@ -58,8 +58,8 @@ class TextInlines {
     let currentLineWidth;
     let flattenedTextArray = flattenTextArray(textArray);
     const textBreaker = new _TextBreaker.default();
-    let breakedText = textBreaker.getBreaks(flattenedTextArray, styleContextStack);
-    let measuredText = this.measure(breakedText, styleContextStack);
+    let brokenText = textBreaker.getBreaks(flattenedTextArray, styleContextStack);
+    let measuredText = this.measure(brokenText, styleContextStack);
     measuredText.forEach(inline => {
       minWidth = Math.max(minWidth, getTrimmedWidth(inline));
       if (!currentLineWidth) {

package/js/base.js

@@ -5,6 +5,7 @@ exports.default = void 0;
 var _Printer = _interopRequireDefault(require("./Printer"));
 var _virtualFs = _interopRequireDefault(require("./virtual-fs"));
 var _tools = require("./helpers/tools");
+var _variableType = require("./helpers/variableType");
 function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 class pdfmake {
   constructor() {
@@ -18,6 +19,12 @@ class pdfmake {
    * @returns {object}
    */
   createPdf(docDefinition, options = {}) {
+    if (!(0, _variableType.isObject)(docDefinition)) {
+      throw new Error("Parameter 'docDefinition' has an invalid type. Object expected.");
+    }
+    if (!(0, _variableType.isObject)(options)) {
+      throw new Error("Parameter 'options' has an invalid type. Object expected.");
+    }
     options.progressCallback = this.progressCallback;
     options.tableLayouts = this.tableLayouts;
     let printer = new _Printer.default(this.fonts, this.virtualfs, this.urlResolver());

package/js/qrEnc.js

@@ -98,7 +98,7 @@ var MASKFUNCS = [function (i, j) {
   return ((i + j) % 2 + i * j % 3) % 2 === 0;
 }];
 
-// returns true when the version information has to be embeded.
+// returns true when the version information has to be embedded.
 var needsverinfo = function (ver) {
   return ver > 6;
 };
@@ -291,7 +291,7 @@ var encode = function (ver, mode, data, maxbuflen) {
 //
 // this is quite similar to CRC calculation as both Reed-Solomon and CRC use
 // the certain kind of cyclic codes, which is effectively the division of
-// zero-augumented polynomial by the generator polynomial. the only difference
+// zero-augmented polynomial by the generator polynomial. the only difference
 // is that Reed-Solomon uses GF(2^8), instead of CRC's GF(2), and Reed-Solomon
 // uses the different generator polynomial than CRC's.
 var calculateecc = function (poly, genpoly) {
@@ -310,10 +310,10 @@ var calculateecc = function (poly, genpoly) {
   return modulus.slice(polylen);
 };
 
-// auguments ECC code words to given code words. the resulting words are
+// augments ECC code words to given code words. the resulting words are
 // ready to be encoded in the matrix.
 //
-// the much of actual augumenting procedure follows JIS X 0510:2004 sec 8.7.
+// the much of actual augmenting procedure follows JIS X 0510:2004 sec 8.7.
 // the code is simplified using the fact that the size of each code & ECC
 // blocks is almost same; for example, when we have 4 blocks and 46 data words
 // the number of code words in those blocks are 11, 11, 12, 12 respectively.
@@ -353,7 +353,7 @@ var augumenteccs = function (poly, nblocks, genpoly) {
   return result;
 };
 
-// auguments BCH(p+q,q) code to the polynomial over GF(2), given the proper
+// augments BCH(p+q,q) code to the polynomial over GF(2), given the proper
 // genpoly. the both input and output are in binary numbers, and unlike
 // calculateecc genpoly should include the 1 bit for the highest degree.
 //
@@ -490,7 +490,7 @@ var putformatinfo = function (matrix, reserved, ecclevel, mask) {
 // (cf. JIS X 0510:2004 sec 8.8.2)
 //
 // the evaluation procedure tries to avoid the problematic patterns naturally
-// occuring from the original matrix. for example, it penaltizes the patterns
+// occurring from the original matrix. for example, it penaltizes the patterns
 // which just look like the finder pattern which will confuse the decoder.
 // we choose the mask which results in the lowest score among 8 possible ones.
 //

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pdfmake",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Client/server side PDF printing in pure JavaScript",
   "main": "js/index.js",
   "esnext": "src/index.js",
@@ -39,7 +39,7 @@
     "source-map-loader": "^5.0.0",
     "stream-browserify": "^3.0.0",
     "string-replace-webpack-plugin": "^0.1.3",
-    "svg-to-pdfkit": "^0.1.8",
+    "svg-to-pdfkit": "github:alafr/SVG-to-PDFKit#b091ebd4e7b7d2310eb1003511cd5de480f7e0e1",
     "terser-webpack-plugin": "^5.3.16",
     "transform-loader": "^0.2.4",
     "util": "^0.12.5",

package/src/3rd-party/svg-to-pdfkit/source.js

@@ -60,7 +60,8 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       'display':            {inherit: false, initial: 'inline', values: {'none':'none', 'inline':'inline', 'block':'inline'}},
       'clip-path':          {inherit: false, initial: 'none'},
       'mask':               {inherit: false, initial: 'none'},
-      'overflow':           {inherit: false, initial: 'hidden', values: {'hidden':'hidden', 'scroll':'hidden', 'visible':'visible'}}
+      'overflow':           {inherit: false, initial: 'hidden', values: {'hidden':'hidden', 'scroll':'hidden', 'visible':'visible'}},
+      'vector-effect':      {inherit: true, initial: 'none', values: {'none':'none', 'non-scaling-stroke':'non-scaling-stroke'}}
     };
 
     function docBeginGroup(bbox) {
@@ -113,11 +114,13 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       doc.addContent('/' + name + ' gs');
     }
     function docCreatePattern(group, dx, dy, matrix) {
-      let pattern = new (function PDFPattern() {})();
-      pattern.group = group;
-      pattern.dx = dx;
-      pattern.dy = dy;
-      pattern.matrix = matrix || [1, 0, 0, 1, 0, 0];
+      let pattern = {
+        type: 'PDFPattern',
+        group: group,
+        dx: dx,
+        dy: dy,
+        matrix: matrix || [1, 0, 0, 1, 0, 0],
+      }
       return pattern;
     }
     function docUsePattern(pattern, stroke) {
@@ -153,14 +156,62 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       let mode = fill && stroke ? 2 : stroke ? 1 : fill ? 0 : 3;
       doc.addContent(mode + ' Tr');
     }
-    function docWriteGlyph(glyph) {
-      doc.addContent('<' + glyph + '> Tj');
+    function docWriteGlyphs(positions, font) {
+      let commands = [];
+      let commandStr = '';
+      const skew = font.fauxItalic ? -0.25 : 0;
+
+      // Add the given character to the 'TJ' command string.
+      function addChar(char) {
+        commandStr += char.glyph;
+        if (char.kern === 0) return;
+        commands.push(`<${commandStr}> ${validateNumber(char.kern)}`);
+        commandStr = '';
+      };
+
+      // Flush the current TJ command string to the output stream.
+      function flush() {
+        if (commandStr.length) {
+          commands.push(`<${commandStr}> 0`);
+          commandStr = '';
+        }
+        if (commands.length) {
+          doc.addContent(`[${commands.join(' ')}] TJ`);
+          commands = [];
+        }
+      };
+
+      for (let i = 0; i < positions.length; i++) {
+        const pos = positions[i];
+
+        if (pos.hidden || isEqual(pos.width, 0)) {
+          flush();
+          continue;
+        }
+
+        if (pos.continuous) {
+          addChar(pos);
+          continue;
+        }
+
+        // If this character is non-continuous, flush the command buffer.
+        flush();
+
+        // Start a new TJ command after writing a Text Matrix (Tm)
+        const cos = Math.cos(pos.rotate);
+        const sin = Math.sin(pos.rotate);
+        docSetTextMatrix(cos * pos.scale, sin * pos.scale, cos * skew - sin, sin * skew + cos, pos.x, pos.y);
+        addChar(pos);
+      };
+
+      // Flush any remaining characters in the buffer.
+      flush();
     }
     function docEndText() {
       doc.addContent('ET');
     }
     function docFillColor(color) {
-      if (color[0].constructor.name === 'PDFPattern') {
+      if (color[0].type === 'PDFPattern') {
         doc.fillOpacity(color[1]);
         docUsePattern(color[0], false);
       } else {
@@ -168,13 +219,127 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       }
     }
     function docStrokeColor(color) {
-      if (color[0].constructor.name === 'PDFPattern') {
+      if (color[0].type === 'PDFPattern') {
         doc.strokeOpacity(color[1]);
         docUsePattern(color[0], true);
       } else {
         doc.strokeColor(color[0], color[1]);
       }
     }
+    // PDFKit doesn't accept any 0s in the dash array, but that's perfectly
+    // valid in SVG. So this function applys a dash array and offset, detecting
+    // any 0s in the dash array and updating it and the dash offset as needed to
+    // remove the zeros, but preserve the end result.
+    //
+    // `dashArray` must have an even number of elements
+    function docApplyDash(dashArray, dashOffset) {
+      let index;
+      // Anytime there's a 0 that isn't the first or last element of the array,
+      // we can remove it by combining the previous or next value. If it's a
+      // dash, then it's a zero-length dash between two spaces, so the dash can
+      // be eliminated and spaces combined by summing them, replacing all three
+      // values with the sum of the two spaces. If the 0 value is a space, then
+      // it's a zero-length space between two dashes, and the dashes can be
+      // similarly combined. So first we run that logic iteratively to remove
+      // all the 0s from the dash array that aren't the first or last element.
+      // Note that because we replace 3 values with one value, this doesn't
+      // change the even-ness of the length of dashArray.
+      while ((index = dashArray.slice(1, -1).indexOf(0)) !== -1) {
+        let actualIndex = index + 1;
+        let replacementValue = dashArray[actualIndex - 1] + dashArray[actualIndex + 1];
+        dashArray = dashArray
+          .slice(0, actualIndex - 1)
+          .concat([replacementValue])
+          .concat(dashArray.slice(actualIndex + 2));
+      }
+
+      // The stroke array only having two elements (a dash value and space
+      // value) is a special case.
+      if (dashArray.length === 2) {
+        if (dashArray[0] === 0) {
+          // Regardless of the space value, the dash length is zero, so we're
+          // not actually drawing a stroke. We can't describe that in a
+          // doc.dash() call in a way that PDFKit will accept, so we set the
+          // stroke opacity to zero as our best approximation.
+          doc.strokeOpacity(0);
+          return;
+        } else if (dashArray[1] === 0) {
+          // Regardless of the dash value, the space value is zero, meaning
+          // we're actually drawing a solid stroke, not a dashed one. We can
+          // make this happen by just emptying out the dash array.
+          dashArray = [];
+        }
+      } else {
+        if (dashArray[0] === 0) {
+          // The first dash is zero-length. We fix this by combining the first
+          // space (just after the first dash) with the last space and updating
+          // the dash offset accordingly. For example, if we had
+          //
+          // [ 0 4 3 2 5 1 ] (dash offset 0)
+          //
+          // ␣␣␣␣---␣␣-----␣
+          // ⎸
+          //
+          // we'd end up with
+          //
+          // [ 3 2 5 5 ] (dash offset -4)
+          //
+          // ---␣␣-----␣␣␣␣␣
+          //            ⎸
+          //
+          // Another example where the dash array also ends with a 0:
+          //
+          // [ 0 4 3 2 5 0 ] (dash offset 0)
+          //
+          // ␣␣␣␣---␣␣-----
+          // ⎸
+          //
+          // we'd end up with
+          //
+          // [ 3 2 5 4 ] (dash offset -4)
+          //
+          // ---␣␣-----␣␣␣␣
+          //           ⎸
+          dashOffset -= dashArray[1];
+          dashArray[dashArray.length - 1] += dashArray[1];
+          dashArray = dashArray.slice(2);
+        }
+        if (dashArray[dashArray.length - 1] === 0) {
+          // The last space is zero-length. We fix this by combining the last dash
+          // (just before the last space) with the first dash and updating the
+          // dash offset accordingly. For example, if we had
+          //
+          // [ 1 4 3 2 5 0 ] (dash offset 0)
+          //
+          // -␣␣␣␣---␣␣-----
+          // ⎸
+          //
+          // we'd end up with
+          //
+          // [ 6 4 3 2 ] (dash offset 5)
+          //
+          // ------␣␣␣␣---␣␣
+          //      ⎸
+          //
+          dashOffset += dashArray[dashArray.length - 2];
+          dashArray[0] += dashArray[dashArray.length - 2];
+          dashArray = dashArray.slice(0, -2);
+        }  
+      }
+
+      // Ensure the dash offset is non-negative (because of crbug.com/660850).
+      // First compute the total length of the dash array so we can add it to
+      // dash offset until dash offset is non-negative.
+      let length = 0;
+      for (let i = 0; i < dashArray.length; i++) {length += dashArray[i];}
+      if (length > 0) {
+        while (dashOffset < 0) {
+          dashOffset += length;
+        }
+      }
+
+      doc.dash(dashArray, {phase: dashOffset});
+    }
     function docInsertLink(x, y, w, h, url) {
       let ref = doc.ref({
         Type: 'Annot',
@@ -308,6 +473,11 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       raw = (raw || '').trim();
       if (temp = NamedColors[raw]) {
         result = [temp.slice(), 1];
+      } else if (temp = raw.match(/^cmyk\(\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9.]+)\s*\)$/i)) {
+        temp[1] = parseInt(temp[1]); temp[2] = parseInt(temp[2]); temp[3] = parseInt(temp[3]); temp[4] = parseFloat(temp[4]);
+        if (temp[1] <= 100 && temp[2] <= 100 && temp[3] <= 100 && temp[4] <= 100) {
+          result = [temp.slice(1, 5), 1];
+        }
       } else if (temp = raw.match(/^rgba\(\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9]+)\s*,\s*([0-9.]+)\s*\)$/i)) {
         temp[1] = parseInt(temp[1]); temp[2] = parseInt(temp[2]); temp[3] = parseInt(temp[3]); temp[4] = parseFloat(temp[4]);
         if (temp[1] < 256 && temp[2] < 256 && temp[3] < 256 && temp[4] <= 1) {
@@ -367,6 +537,11 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       return new SvgShape().M(0, 0).L(doc.page.width, 0).L(doc.page.width, doc.page.height).L(0, doc.page.height)
                            .transform(inverseMatrix(getGlobalMatrix())).getBoundingBox();
     }
+    function getPageScale() {
+      const bbox = getPageBBox();
+      const width = doc.page.width;
+      return width / bbox[2];
+    }
     function inverseMatrix(m) {
       let dt = m[0] * m[3] - m[1] * m[2];
       return [m[3] / dt, -m[1] / dt, -m[2] / dt, m[0] / dt, (m[2]*m[5] - m[3]*m[4]) / dt, (m[1]*m[4] - m[0]*m[5]) / dt];
@@ -556,7 +731,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
         if (selector.ids[i] !== elem.id) {return false;}
       }
       for (let i = 0; i < selector.classes.length; i++) {
-        if (elem.classList.indexOf(selector.classes[i]) === -1) {return false;}
+        if (!elem.classList.contains(selector.classes[i])) {return false;}
       }
       return true;
     }
@@ -615,6 +790,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
         data.push({
           glyph: hex[i],
           unicode: unicode,
+          kern: pos[i].advanceWidth - pos[i].xAdvance,
           width: pos[i].advanceWidth * size / 1000,
           xOffset: pos[i].xOffset * size / 1000,
           yOffset: pos[i].yOffset * size / 1000,
@@ -1266,12 +1442,6 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
                 break;
               case 'stroke-dashoffset':
                 result = this.computeLength(value, this.getViewport());
-                if (result != null) {
-                  if (result < 0) { // fix for crbug.com/660850
-                    let dasharray = this.get('stroke-dasharray');
-                    for (let j = 0; j < dasharray.length; j++) {result += dasharray[j];}
-                  }
-                }
                 break;
             }
             if (result != null) {return styleCache[key] = result;}
@@ -1322,7 +1492,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       this.clip = function() {
         if (this.get('clip-path') !== 'none') {
           let clipPath = new SvgElemClipPath(this.get('clip-path'), null);
-          clipPath.useMask(this.getBoundingBox());
+          clipPath.useMask((clipPath.attr('clipPathUnits') === 'objectBoundingBox') ? this.getBoundingBox() : null);
           return true;
         }
       };
@@ -1788,7 +1958,11 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       this.drawInDocument = function(isClip, isMask) {
         if (this.get('visibility') === 'hidden' || !this.shape) {return;}
         doc.save();
-        this.transform();
+        if (this.get('vector-effect') === 'non-scaling-stroke') {
+          this.shape.transform(this.getTransformation());
+        } else {
+          this.transform();
+        }
         this.clip();
         if (!isClip) {
           let masked = this.mask(),
@@ -1801,6 +1975,11 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
               stroke = this.getStroke(isClip, isMask),
               lineWidth = this.get('stroke-width'),
               lineCap = this.get('stroke-linecap');
+
+          if (this.get('vector-effect') === 'non-scaling-stroke') {
+            lineWidth = lineWidth / getPageScale();
+          }
+          
           if (fill || stroke) {
             if (fill) {
               docFillColor(fill);
@@ -1835,8 +2014,8 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
               doc.lineWidth(lineWidth)
                  .miterLimit(this.get('stroke-miterlimit'))
                  .lineJoin(this.get('stroke-linejoin'))
-                 .lineCap(lineCap)
-                 .dash(dashArray, {phase: dashOffset});
+                 .lineCap(lineCap);
+              docApplyDash(dashArray, dashOffset);
             }
             for (let j = 0; j < subPaths.length; j++) {
               if (subPaths[j].totalLength > 0) {
@@ -1856,7 +2035,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
               markerEnd = this.get('marker-end');
           if (markerStart !== 'none' || markerMid !== 'none' || markerEnd !== 'none') {
             let markersPos = this.shape.getMarkers();
-            if (markerStart !== 'none') {
+            if (markerStart !== 'none' && markersPos.length > 0) {
               let marker = new SvgElemMarker(markerStart, null);
               marker.drawMarker(false, isMask, markersPos[0], lineWidth);
             }
@@ -1866,7 +2045,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
                 marker.drawMarker(false, isMask, markersPos[i], lineWidth);
               }
             }
-            if (markerEnd !== 'none') {
+            if (markerEnd !== 'none' && markersPos.length > 0) {
               let marker = new SvgElemMarker(markerEnd, null);
               marker.drawMarker(false, isMask, markersPos[markersPos.length - 1], lineWidth);
             }
@@ -2028,6 +2207,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
       this.useMask = function(bBox) {
         let group = docBeginGroup(getPageBBox());
         doc.save();
+        doc.transform.apply(doc, this.get('transform'));
         if (this.attr('clipPathUnits') === 'objectBoundingBox') {
           doc.transform(bBox[2] - bBox[0], 0, 0, bBox[3] - bBox[1], bBox[0], bBox[1]);
         }
@@ -2056,7 +2236,6 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
           w = this.getLength('width', this.getVWidth(), 1.2) * (bBox[2] - bBox[0]);
           h = this.getLength('height', this.getVHeight(), 1.2) * (bBox[3] - bBox[1]);
         }
-        doc.rect(x, y, w, h).clip();
         if (this.attr('maskContentUnits') === 'objectBoundingBox') {
           doc.transform(bBox[2] - bBox[0], 0, 0, bBox[3] - bBox[1], bBox[0], bBox[1]);
         }
@@ -2125,18 +2304,12 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
                   doc.lineWidth(strokeWidth)
                      .miterLimit(this.get('stroke-miterlimit'))
                      .lineJoin(this.get('stroke-linejoin'))
-                     .lineCap(this.get('stroke-linecap'))
-                     .dash(this.get('stroke-dasharray'), {phase:this.get('stroke-dashoffset')});
+                     .lineCap(this.get('stroke-linecap'));
+                  docApplyDash(this.get('stroke-dasharray'), this.get('stroke-dashoffset'));
                 }
                 docBeginText(this._font.font, this._font.size);
                 docSetTextMode(!!fill, !!stroke);
-                for (let j = 0, pos = childElem._pos; j < pos.length; j++) {
-                  if (!pos[j].hidden && isNotEqual(pos[j].width, 0)) {
-                    let cos = Math.cos(pos[j].rotate), sin = Math.sin(pos[j].rotate), skew = (this._font.fauxItalic ? -0.25 : 0);
-                    docSetTextMatrix(cos * pos[j].scale, sin * pos[j].scale, cos * skew - sin, sin * skew + cos, pos[j].x, pos[j].y);
-                    docWriteGlyph(pos[j].glyph);
-                  }
-                }
+                docWriteGlyphs(childElem._pos, this._font);
                 docEndText();
               }
               break;
@@ -2157,8 +2330,8 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
           doc.lineWidth(this.get('stroke-width'))
              .miterLimit(this.get('stroke-miterlimit'))
              .lineJoin(this.get('stroke-linejoin'))
-             .lineCap(this.get('stroke-linecap'))
-             .dash(this.get('stroke-dasharray'), {phase:this.get('stroke-dashoffset')});
+             .lineCap(this.get('stroke-linecap'));
+          docApplyDash(this.get('stroke-dasharray'), this.get('stroke-dashoffset'));
         }
         for (let j = 0, pos = this._pos; j < pos.length; j++) {
           if (!pos[j].hidden && isNotEqual(pos[j].width, 0)) {
@@ -2234,6 +2407,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
             let textScale = length / (endX - startX);
             if (textScale > 0 && textScale < Infinity) {
               for (let j = 0; j < pos.length; j++) {
+                pos[j].continuous = false;
                 pos[j].x = startX + textScale * (pos[j].x - startX);
                 pos[j].scale *= textScale;
                 pos[j].width *= textScale;
@@ -2243,6 +2417,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
             if (pos.length >= 2) {
               let spaceDiff = (length - (endX - startX)) / (pos.length - 1);
               for (let j = 0; j < pos.length; j++) {
+                pos[j].continuous = false;
                 pos[j].x += j * spaceDiff;
               }
             }
@@ -2262,7 +2437,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
           try {
             doc.font(fontNameorLink);
           } catch(e) {
-            warningCallback('SVGElemText: failed to open font "' + fontNameorLink + '" in PDFKit');
+            warningCallback('SVGElemText: failed to open font "' + fontNameorLink + '" in PDFKit: ' + e.message);
           }
           currentElem._pos = [];
           currentElem._index = 0;
@@ -2273,7 +2448,22 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
               letterSpacing = currentElem.get('letter-spacing'),
               textAnchor = currentElem.get('text-anchor'),
               textDirection = currentElem.get('direction'),
-              baseline = getBaseline(currentElem._font.font, currentElem._font.size, currentElem.get('alignment-baseline') || currentElem.get('dominant-baseline'), currentElem.get('baseline-shift'));
+              // `alignment-baseline` and `baseline-shift` have no effect on
+              // `<text>` elements according to the SVG spec. So, detect when
+              // we're styling a `<text>` element and ignore
+              // `alignment-baseline` (only factoring in `dominant-baseline`)
+              // and `baseline-shift` (which can only have the default value of
+              // `baseline`).
+              //
+              // Note that Chrome (as of v99) incorrectly factors in
+              // `alignment-baseline` on `<text>` elements, while Firefox
+              // correctly follows the spec and ignores it. This means that our
+              // output will differ from Chrome's in these cases, but conform to
+              // SVG specification.
+              isTextElem = currentElem.name === 'text',
+              baselineAttr = isTextElem ? currentElem.get('dominant-baseline') : (currentElem.get('alignment-baseline') || currentElem.get('dominant-baseline')),
+              baselineShiftAttr = isTextElem ? 'baseline' : currentElem.get('baseline-shift'),
+              baseline = getBaseline(currentElem._font.font, currentElem._font.size, baselineAttr, baselineShiftAttr);
           if (currentElem.name === 'textPath') {
             doAnchoring();
             currentX = currentY = 0;
@@ -2313,6 +2503,8 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
                         dyAttr = currentElem._dy[index],
                         rotAttr = currentElem._rot[index],
                         continuous = !(w === 0 && j === 0);
+                    if (letterSpacing !== 0) {continuous = false}
+                    if (wordSpacing !== 0) {continuous = false}
                     if (xAttr !== undefined) {continuous = false; doAnchoring(); currentX = xAttr;}
                     if (yAttr !== undefined) {continuous = false; doAnchoring(); currentY = yAttr;}
                     if (dxAttr !== undefined) {continuous = false; currentX += dxAttr;}
@@ -2322,6 +2514,7 @@ var SVGtoPDF = function(doc, svg, x, y, options) {
                       glyph: pos[j].glyph,
                       rotate: (Math.PI / 180) * currentElem.chooseValue(rotAttr, currentElem._defRot),
                       x: currentX + pos[j].xOffset,
+                      kern: pos[j].kern,
                       y: currentY + baseline + pos[j].yOffset,
                       width: pos[j].width,
                       ascent: getAscent(currentElem._font.font, currentElem._font.size),

package/src/OutputDocumentServer.js

@@ -9,11 +9,22 @@ class OutputDocumentServer extends OutputDocument {
 	 */
 	async write(filename) {
 		const stream = await this.getStream();
-		return new Promise((resolve) => {
-			stream.pipe(fs.createWriteStream(filename));
+		const writeStream = fs.createWriteStream(filename);
+
+		const streamEnded = new Promise((resolve, reject) => {
 			stream.on('end', resolve);
-			stream.end();
+			stream.on('error', reject);
+		});
+
+		const writeClosed = new Promise((resolve, reject) => {
+			writeStream.on('close', resolve);
+			writeStream.on('error', reject);
 		});
+
+		stream.pipe(writeStream);
+		stream.end();
+
+		await Promise.all([streamEnded, writeClosed]);
 	}
 
 }

package/src/Printer.js

@@ -102,12 +102,11 @@ class PdfPrinter {
 
 		// if pageSize.height is set to Infinity, calculate the actual height of the page that
 		// was laid out using the height of each of the items in the page.
-		if (pageSize.height === Infinity) {
-			let pageHeight = calculatePageHeight(pages, docDefinition.pageMargins);
-			pages.forEach(page => {
-				page.pageSize.height = pageHeight;
-			});
-		}
+		pages.forEach(page => {
+			if (page.pageSize.height === Infinity) {
+				page.pageSize.height = calculatePageHeight(page, page.pageMargins);
+			}
+		});
 
 		const renderer = new Renderer(this.pdfKitDoc, options.progressCallback);
 		renderer.renderPages(pages);
@@ -265,7 +264,7 @@ function embedFiles(docDefinition, pdfKitDoc) {
 	}
 }
 
-function calculatePageHeight(pages, margins) {
+function calculatePageHeight(page, margins) {
 	function getItemHeight(item) {
 		if (typeof item.item.getHeight === 'function') {
 			return item.item.getHeight();
@@ -292,13 +291,11 @@ function calculatePageHeight(pages, margins) {
 	let fixedMargins = normalizePageMargin(margins || 40);
 	let height = fixedMargins.top;
 
-	pages.forEach(page => {
-		page.items.forEach(item => {
-			let bottomPosition = getBottomPosition(item);
-			if (bottomPosition > height) {
-				height = bottomPosition;
-			}
-		});
+	page.items.forEach(item => {
+		let bottomPosition = getBottomPosition(item);
+		if (bottomPosition > height) {
+			height = bottomPosition;
+		}
 	});
 
 	height += fixedMargins.bottom;

package/src/Renderer.js

@@ -1,6 +1,6 @@
 import TextDecorator from './TextDecorator';
 import TextInlines from './TextInlines';
-import { isNumber } from './helpers/variableType';
+import { isNumber, isString } from './helpers/variableType';
 import SVGtoPDF from './3rd-party/svg-to-pdfkit';
 
 const findFont = (fonts, requiredFonts, defaultFont) => {
@@ -138,7 +138,7 @@ class Renderer {
 		textDecorator.drawBackground(line, x, y);
 
 		//TODO: line.optimizeInlines();
-		//TOOD: lines without differently styled inlines should be written to pdf as one stream
+		//TODO: lines without differently styled inlines should be written to pdf as one stream
 		for (let i = 0, l = line.inlines.length; i < l; i++) {
 			let inline = line.inlines[i];
 			let shiftToBaseline = lineHeight - ((inline.font.ascender / 1000) * inline.fontSize) - descent;
@@ -329,7 +329,13 @@ class Renderer {
 	}
 
 	renderSVG(svg) {
-		let options = Object.assign({ width: svg._width, height: svg._height, assumePt: true }, svg.options);
+		let options = {
+			width: svg._width,
+			height: svg._height,
+			assumePt: true,
+			useCSS: !isString(svg.svg),
+			...svg.options
+		};
 		options.fontCallback = (family, bold, italic) => {
 			let fontsFamily = family.split(',').map(f => f.trim().replace(/('|")/g, ''));
 			let font = findFont(this.pdfDocument.fonts, fontsFamily, svg.font || 'Roboto');