ps-toolkit-ui 0.0.207 → 0.0.211

package/src/assets/plugins/highcharts/code/lib/svg2pdf.src.js

@@ -0,0 +1,4390 @@
+/**
+ * Modules in this bundle
+ * @license
+ *
+ * svg2pdf.js:
+ *   license: MIT (http://opensource.org/licenses/MIT)
+ *   author: yFiles for HTML Support Team <yfileshtml@yworks.com>
+ *   homepage: https://github.com/yWorks/svg2pdf.js#readme
+ *   version: 1.3.1
+ *
+ * cssesc:
+ *   license: MIT (http://opensource.org/licenses/MIT)
+ *   author: Mathias Bynens
+ *   homepage: https://mths.be/cssesc
+ *   version: 2.0.0
+ *
+ * font-family:
+ *   license: MIT (http://opensource.org/licenses/MIT)
+ *   author: Taro Hanamura <m@hanamurataro.com>
+ *   homepage: https://github.com/hanamura/font-family
+ *   version: 0.2.0
+ *
+ * svgpath:
+ *   license: MIT (http://opensource.org/licenses/MIT)
+ *   homepage: https://github.com/fontello/svgpath#readme
+ *   version: 2.2.1
+ *
+ * This header is generated by licensify (https://github.com/twada/licensify)
+ */
+(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.svg2pdf = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
+'use strict';
+
+module.exports = require('./lib/svgpath');
+
+},{"./lib/svgpath":6}],2:[function(require,module,exports){
+// Convert an arc to a sequence of cubic bézier curves
+//
+'use strict';
+
+
+var TAU = Math.PI * 2;
+
+
+/* eslint-disable space-infix-ops */
+
+// Calculate an angle between two vectors
+//
+function vector_angle(ux, uy, vx, vy) {
+  var sign = (ux * vy - uy * vx < 0) ? -1 : 1;
+  var umag = Math.sqrt(ux * ux + uy * uy);
+  var vmag = Math.sqrt(ux * ux + uy * uy);
+  var dot  = ux * vx + uy * vy;
+  var div  = dot / (umag * vmag);
+
+  // rounding errors, e.g. -1.0000000000000002 can screw up this
+  if (div >  1.0) { div =  1.0; }
+  if (div < -1.0) { div = -1.0; }
+
+  return sign * Math.acos(div);
+}
+
+
+// Convert from endpoint to center parameterization,
+// see http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes
+//
+// Return [cx, cy, theta1, delta_theta]
+//
+function get_arc_center(x1, y1, x2, y2, fa, fs, rx, ry, sin_phi, cos_phi) {
+  // Step 1.
+  //
+  // Moving an ellipse so origin will be the middlepoint between our two
+  // points. After that, rotate it to line up ellipse axes with coordinate
+  // axes.
+  //
+  var x1p =  cos_phi*(x1-x2)/2 + sin_phi*(y1-y2)/2;
+  var y1p = -sin_phi*(x1-x2)/2 + cos_phi*(y1-y2)/2;
+
+  var rx_sq  =  rx * rx;
+  var ry_sq  =  ry * ry;
+  var x1p_sq = x1p * x1p;
+  var y1p_sq = y1p * y1p;
+
+  // Step 2.
+  //
+  // Compute coordinates of the centre of this ellipse (cx', cy')
+  // in the new coordinate system.
+  //
+  var radicant = (rx_sq * ry_sq) - (rx_sq * y1p_sq) - (ry_sq * x1p_sq);
+
+  if (radicant < 0) {
+    // due to rounding errors it might be e.g. -1.3877787807814457e-17
+    radicant = 0;
+  }
+
+  radicant /=   (rx_sq * y1p_sq) + (ry_sq * x1p_sq);
+  radicant = Math.sqrt(radicant) * (fa === fs ? -1 : 1);
+
+  var cxp = radicant *  rx/ry * y1p;
+  var cyp = radicant * -ry/rx * x1p;
+
+  // Step 3.
+  //
+  // Transform back to get centre coordinates (cx, cy) in the original
+  // coordinate system.
+  //
+  var cx = cos_phi*cxp - sin_phi*cyp + (x1+x2)/2;
+  var cy = sin_phi*cxp + cos_phi*cyp + (y1+y2)/2;
+
+  // Step 4.
+  //
+  // Compute angles (theta1, delta_theta).
+  //
+  var v1x =  (x1p - cxp) / rx;
+  var v1y =  (y1p - cyp) / ry;
+  var v2x = (-x1p - cxp) / rx;
+  var v2y = (-y1p - cyp) / ry;
+
+  var theta1 = vector_angle(1, 0, v1x, v1y);
+  var delta_theta = vector_angle(v1x, v1y, v2x, v2y);
+
+  if (fs === 0 && delta_theta > 0) {
+    delta_theta -= TAU;
+  }
+  if (fs === 1 && delta_theta < 0) {
+    delta_theta += TAU;
+  }
+
+  return [ cx, cy, theta1, delta_theta ];
+}
+
+//
+// Approximate one unit arc segment with bézier curves,
+// see http://math.stackexchange.com/questions/873224
+//
+function approximate_unit_arc(theta1, delta_theta) {
+  var alpha = 4/3 * Math.tan(delta_theta/4);
+
+  var x1 = Math.cos(theta1);
+  var y1 = Math.sin(theta1);
+  var x2 = Math.cos(theta1 + delta_theta);
+  var y2 = Math.sin(theta1 + delta_theta);
+
+  return [ x1, y1, x1 - y1*alpha, y1 + x1*alpha, x2 + y2*alpha, y2 - x2*alpha, x2, y2 ];
+}
+
+module.exports = function a2c(x1, y1, x2, y2, fa, fs, rx, ry, phi) {
+  var sin_phi = Math.sin(phi * TAU / 360);
+  var cos_phi = Math.cos(phi * TAU / 360);
+
+  // Make sure radii are valid
+  //
+  var x1p =  cos_phi*(x1-x2)/2 + sin_phi*(y1-y2)/2;
+  var y1p = -sin_phi*(x1-x2)/2 + cos_phi*(y1-y2)/2;
+
+  if (x1p === 0 && y1p === 0) {
+    // we're asked to draw line to itself
+    return [];
+  }
+
+  if (rx === 0 || ry === 0) {
+    // one of the radii is zero
+    return [];
+  }
+
+
+  // Compensate out-of-range radii
+  //
+  rx = Math.abs(rx);
+  ry = Math.abs(ry);
+
+  var lambda = (x1p * x1p) / (rx * rx) + (y1p * y1p) / (ry * ry);
+  if (lambda > 1) {
+    rx *= Math.sqrt(lambda);
+    ry *= Math.sqrt(lambda);
+  }
+
+
+  // Get center parameters (cx, cy, theta1, delta_theta)
+  //
+  var cc = get_arc_center(x1, y1, x2, y2, fa, fs, rx, ry, sin_phi, cos_phi);
+
+  var result = [];
+  var theta1 = cc[2];
+  var delta_theta = cc[3];
+
+  // Split an arc to multiple segments, so each segment
+  // will be less than τ/4 (= 90°)
+  //
+  var segments = Math.max(Math.ceil(Math.abs(delta_theta) / (TAU / 4)), 1);
+  delta_theta /= segments;
+
+  for (var i = 0; i < segments; i++) {
+    result.push(approximate_unit_arc(theta1, delta_theta));
+    theta1 += delta_theta;
+  }
+
+  // We have a bezier approximation of a unit circle,
+  // now need to transform back to the original ellipse
+  //
+  return result.map(function (curve) {
+    for (var i = 0; i < curve.length; i += 2) {
+      var x = curve[i + 0];
+      var y = curve[i + 1];
+
+      // scale
+      x *= rx;
+      y *= ry;
+
+      // rotate
+      var xp = cos_phi*x - sin_phi*y;
+      var yp = sin_phi*x + cos_phi*y;
+
+      // translate
+      curve[i + 0] = xp + cc[0];
+      curve[i + 1] = yp + cc[1];
+    }
+
+    return curve;
+  });
+};
+
+},{}],3:[function(require,module,exports){
+'use strict';
+
+/* eslint-disable space-infix-ops */
+
+// The precision used to consider an ellipse as a circle
+//
+var epsilon = 0.0000000001;
+
+// To convert degree in radians
+//
+var torad = Math.PI / 180;
+
+// Class constructor :
+//  an ellipse centred at 0 with radii rx,ry and x - axis - angle ax.
+//
+function Ellipse(rx, ry, ax) {
+  if (!(this instanceof Ellipse)) { return new Ellipse(rx, ry, ax); }
+  this.rx = rx;
+  this.ry = ry;
+  this.ax = ax;
+}
+
+// Apply a linear transform m to the ellipse
+// m is an array representing a matrix :
+//    -         -
+//   | m[0] m[2] |
+//   | m[1] m[3] |
+//    -         -
+//
+Ellipse.prototype.transform = function (m) {
+  // We consider the current ellipse as image of the unit circle
+  // by first scale(rx,ry) and then rotate(ax) ...
+  // So we apply ma =  m x rotate(ax) x scale(rx,ry) to the unit circle.
+  var c = Math.cos(this.ax * torad), s = Math.sin(this.ax * torad);
+  var ma = [
+    this.rx * (m[0]*c + m[2]*s),
+    this.rx * (m[1]*c + m[3]*s),
+    this.ry * (-m[0]*s + m[2]*c),
+    this.ry * (-m[1]*s + m[3]*c)
+  ];
+
+  // ma * transpose(ma) = [ J L ]
+  //                      [ L K ]
+  // L is calculated later (if the image is not a circle)
+  var J = ma[0]*ma[0] + ma[2]*ma[2],
+      K = ma[1]*ma[1] + ma[3]*ma[3];
+
+  // the discriminant of the characteristic polynomial of ma * transpose(ma)
+  var D = ((ma[0]-ma[3])*(ma[0]-ma[3]) + (ma[2]+ma[1])*(ma[2]+ma[1])) *
+          ((ma[0]+ma[3])*(ma[0]+ma[3]) + (ma[2]-ma[1])*(ma[2]-ma[1]));
+
+  // the "mean eigenvalue"
+  var JK = (J + K) / 2;
+
+  // check if the image is (almost) a circle
+  if (D < epsilon * JK) {
+    // if it is
+    this.rx = this.ry = Math.sqrt(JK);
+    this.ax = 0;
+    return this;
+  }
+
+  // if it is not a circle
+  var L = ma[0]*ma[1] + ma[2]*ma[3];
+
+  D = Math.sqrt(D);
+
+  // {l1,l2} = the two eigen values of ma * transpose(ma)
+  var l1 = JK + D/2,
+      l2 = JK - D/2;
+  // the x - axis - rotation angle is the argument of the l1 - eigenvector
+  this.ax = (Math.abs(L) < epsilon && Math.abs(l1 - K) < epsilon) ?
+    90
+  :
+    Math.atan(Math.abs(L) > Math.abs(l1 - K) ?
+      (l1 - J) / L
+    :
+      L / (l1 - K)
+    ) * 180 / Math.PI;
+
+  // if ax > 0 => rx = sqrt(l1), ry = sqrt(l2), else exchange axes and ax += 90
+  if (this.ax >= 0) {
+    // if ax in [0,90]
+    this.rx = Math.sqrt(l1);
+    this.ry = Math.sqrt(l2);
+  } else {
+    // if ax in ]-90,0[ => exchange axes
+    this.ax += 90;
+    this.rx = Math.sqrt(l2);
+    this.ry = Math.sqrt(l1);
+  }
+
+  return this;
+};
+
+// Check if the ellipse is (almost) degenerate, i.e. rx = 0 or ry = 0
+//
+Ellipse.prototype.isDegenerate = function () {
+  return (this.rx < epsilon * this.ry || this.ry < epsilon * this.rx);
+};
+
+module.exports = Ellipse;
+
+},{}],4:[function(require,module,exports){
+'use strict';
+
+// combine 2 matrixes
+// m1, m2 - [a, b, c, d, e, g]
+//
+function combine(m1, m2) {
+  return [
+    m1[0] * m2[0] + m1[2] * m2[1],
+    m1[1] * m2[0] + m1[3] * m2[1],
+    m1[0] * m2[2] + m1[2] * m2[3],
+    m1[1] * m2[2] + m1[3] * m2[3],
+    m1[0] * m2[4] + m1[2] * m2[5] + m1[4],
+    m1[1] * m2[4] + m1[3] * m2[5] + m1[5]
+  ];
+}
+
+
+function Matrix() {
+  if (!(this instanceof Matrix)) { return new Matrix(); }
+  this.queue = [];   // list of matrixes to apply
+  this.cache = null; // combined matrix cache
+}
+
+
+Matrix.prototype.matrix = function (m) {
+  if (m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1 && m[4] === 0 && m[5] === 0) {
+    return this;
+  }
+  this.cache = null;
+  this.queue.push(m);
+  return this;
+};
+
+
+Matrix.prototype.translate = function (tx, ty) {
+  if (tx !== 0 || ty !== 0) {
+    this.cache = null;
+    this.queue.push([ 1, 0, 0, 1, tx, ty ]);
+  }
+  return this;
+};
+
+
+Matrix.prototype.scale = function (sx, sy) {
+  if (sx !== 1 || sy !== 1) {
+    this.cache = null;
+    this.queue.push([ sx, 0, 0, sy, 0, 0 ]);
+  }
+  return this;
+};
+
+
+Matrix.prototype.rotate = function (angle, rx, ry) {
+  var rad, cos, sin;
+
+  if (angle !== 0) {
+    this.translate(rx, ry);
+
+    rad = angle * Math.PI / 180;
+    cos = Math.cos(rad);
+    sin = Math.sin(rad);
+
+    this.queue.push([ cos, sin, -sin, cos, 0, 0 ]);
+    this.cache = null;
+
+    this.translate(-rx, -ry);
+  }
+  return this;
+};
+
+
+Matrix.prototype.skewX = function (angle) {
+  if (angle !== 0) {
+    this.cache = null;
+    this.queue.push([ 1, 0, Math.tan(angle * Math.PI / 180), 1, 0, 0 ]);
+  }
+  return this;
+};
+
+
+Matrix.prototype.skewY = function (angle) {
+  if (angle !== 0) {
+    this.cache = null;
+    this.queue.push([ 1, Math.tan(angle * Math.PI / 180), 0, 1, 0, 0 ]);
+  }
+  return this;
+};
+
+
+// Flatten queue
+//
+Matrix.prototype.toArray = function () {
+  if (this.cache) {
+    return this.cache;
+  }
+
+  if (!this.queue.length) {
+    this.cache = [ 1, 0, 0, 1, 0, 0 ];
+    return this.cache;
+  }
+
+  this.cache = this.queue[0];
+
+  if (this.queue.length === 1) {
+    return this.cache;
+  }
+
+  for (var i = 1; i < this.queue.length; i++) {
+    this.cache = combine(this.cache, this.queue[i]);
+  }
+
+  return this.cache;
+};
+
+
+// Apply list of matrixes to (x,y) point.
+// If `isRelative` set, `translate` component of matrix will be skipped
+//
+Matrix.prototype.calc = function (x, y, isRelative) {
+  var m;
+
+  // Don't change point on empty transforms queue
+  if (!this.queue.length) { return [ x, y ]; }
+
+  // Calculate final matrix, if not exists
+  //
+  // NB. if you deside to apply transforms to point one-by-one,
+  // they should be taken in reverse order
+
+  if (!this.cache) {
+    this.cache = this.toArray();
+  }
+
+  m = this.cache;
+
+  // Apply matrix to point
+  return [
+    x * m[0] + y * m[2] + (isRelative ? 0 : m[4]),
+    x * m[1] + y * m[3] + (isRelative ? 0 : m[5])
+  ];
+};
+
+
+module.exports = Matrix;
+
+},{}],5:[function(require,module,exports){
+'use strict';
+
+
+var paramCounts = { a: 7, c: 6, h: 1, l: 2, m: 2, r: 4, q: 4, s: 4, t: 2, v: 1, z: 0 };
+
+var SPECIAL_SPACES = [
+  0x1680, 0x180E, 0x2000, 0x2001, 0x2002, 0x2003, 0x2004, 0x2005, 0x2006,
+  0x2007, 0x2008, 0x2009, 0x200A, 0x202F, 0x205F, 0x3000, 0xFEFF
+];
+
+function isSpace(ch) {
+  return (ch === 0x0A) || (ch === 0x0D) || (ch === 0x2028) || (ch === 0x2029) || // Line terminators
+    // White spaces
+    (ch === 0x20) || (ch === 0x09) || (ch === 0x0B) || (ch === 0x0C) || (ch === 0xA0) ||
+    (ch >= 0x1680 && SPECIAL_SPACES.indexOf(ch) >= 0);
+}
+
+function isCommand(code) {
+  /*eslint-disable no-bitwise*/
+  switch (code | 0x20) {
+    case 0x6D/* m */:
+    case 0x7A/* z */:
+    case 0x6C/* l */:
+    case 0x68/* h */:
+    case 0x76/* v */:
+    case 0x63/* c */:
+    case 0x73/* s */:
+    case 0x71/* q */:
+    case 0x74/* t */:
+    case 0x61/* a */:
+    case 0x72/* r */:
+      return true;
+  }
+  return false;
+}
+
+function isDigit(code) {
+  return (code >= 48 && code <= 57);   // 0..9
+}
+
+function isDigitStart(code) {
+  return (code >= 48 && code <= 57) || /* 0..9 */
+          code === 0x2B || /* + */
+          code === 0x2D || /* - */
+          code === 0x2E;   /* . */
+}
+
+
+function State(path) {
+  this.index  = 0;
+  this.path   = path;
+  this.max    = path.length;
+  this.result = [];
+  this.param  = 0.0;
+  this.err    = '';
+  this.segmentStart = 0;
+  this.data   = [];
+}
+
+function skipSpaces(state) {
+  while (state.index < state.max && isSpace(state.path.charCodeAt(state.index))) {
+    state.index++;
+  }
+}
+
+
+function scanParam(state) {
+  var start = state.index,
+      index = start,
+      max = state.max,
+      zeroFirst = false,
+      hasCeiling = false,
+      hasDecimal = false,
+      hasDot = false,
+      ch;
+
+  if (index >= max) {
+    state.err = 'SvgPath: missed param (at pos ' + index + ')';
+    return;
+  }
+  ch = state.path.charCodeAt(index);
+
+  if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
+    index++;
+    ch = (index < max) ? state.path.charCodeAt(index) : 0;
+  }
+
+  // This logic is shamelessly borrowed from Esprima
+  // https://github.com/ariya/esprimas
+  //
+  if (!isDigit(ch) && ch !== 0x2E/* . */) {
+    state.err = 'SvgPath: param should start with 0..9 or `.` (at pos ' + index + ')';
+    return;
+  }
+
+  if (ch !== 0x2E/* . */) {
+    zeroFirst = (ch === 0x30/* 0 */);
+    index++;
+
+    ch = (index < max) ? state.path.charCodeAt(index) : 0;
+
+    if (zeroFirst && index < max) {
+      // decimal number starts with '0' such as '09' is illegal.
+      if (ch && isDigit(ch)) {
+        state.err = 'SvgPath: numbers started with `0` such as `09` are ilegal (at pos ' + start + ')';
+        return;
+      }
+    }
+
+    while (index < max && isDigit(state.path.charCodeAt(index))) {
+      index++;
+      hasCeiling = true;
+    }
+    ch = (index < max) ? state.path.charCodeAt(index) : 0;
+  }
+
+  if (ch === 0x2E/* . */) {
+    hasDot = true;
+    index++;
+    while (isDigit(state.path.charCodeAt(index))) {
+      index++;
+      hasDecimal = true;
+    }
+    ch = (index < max) ? state.path.charCodeAt(index) : 0;
+  }
+
+  if (ch === 0x65/* e */ || ch === 0x45/* E */) {
+    if (hasDot && !hasCeiling && !hasDecimal) {
+      state.err = 'SvgPath: invalid float exponent (at pos ' + index + ')';
+      return;
+    }
+
+    index++;
+
+    ch = (index < max) ? state.path.charCodeAt(index) : 0;
+    if (ch === 0x2B/* + */ || ch === 0x2D/* - */) {
+      index++;
+    }
+    if (index < max && isDigit(state.path.charCodeAt(index))) {
+      while (index < max && isDigit(state.path.charCodeAt(index))) {
+        index++;
+      }
+    } else {
+      state.err = 'SvgPath: invalid float exponent (at pos ' + index + ')';
+      return;
+    }
+  }
+
+  state.index = index;
+  state.param = parseFloat(state.path.slice(start, index)) + 0.0;
+}
+
+
+function finalizeSegment(state) {
+  var cmd, cmdLC;
+
+  // Process duplicated commands (without comand name)
+
+  // This logic is shamelessly borrowed from Raphael
+  // https://github.com/DmitryBaranovskiy/raphael/
+  //
+  cmd   = state.path[state.segmentStart];
+  cmdLC = cmd.toLowerCase();
+
+  var params = state.data;
+
+  if (cmdLC === 'm' && params.length > 2) {
+    state.result.push([ cmd, params[0], params[1] ]);
+    params = params.slice(2);
+    cmdLC = 'l';
+    cmd = (cmd === 'm') ? 'l' : 'L';
+  }
+
+  if (cmdLC === 'r') {
+    state.result.push([ cmd ].concat(params));
+  } else {
+
+    while (params.length >= paramCounts[cmdLC]) {
+      state.result.push([ cmd ].concat(params.splice(0, paramCounts[cmdLC])));
+      if (!paramCounts[cmdLC]) {
+        break;
+      }
+    }
+  }
+}
+
+
+function scanSegment(state) {
+  var max = state.max,
+      cmdCode, comma_found, need_params, i;
+
+  state.segmentStart = state.index;
+  cmdCode = state.path.charCodeAt(state.index);
+
+  if (!isCommand(cmdCode)) {
+    state.err = 'SvgPath: bad command ' + state.path[state.index] + ' (at pos ' + state.index + ')';
+    return;
+  }
+
+  need_params = paramCounts[state.path[state.index].toLowerCase()];
+
+  state.index++;
+  skipSpaces(state);
+
+  state.data = [];
+
+  if (!need_params) {
+    // Z
+    finalizeSegment(state);
+    return;
+  }
+
+  comma_found = false;
+
+  for (;;) {
+    for (i = need_params; i > 0; i--) {
+      scanParam(state);
+      if (state.err.length) {
+        return;
+      }
+      state.data.push(state.param);
+
+      skipSpaces(state);
+      comma_found = false;
+
+      if (state.index < max && state.path.charCodeAt(state.index) === 0x2C/* , */) {
+        state.index++;
+        skipSpaces(state);
+        comma_found = true;
+      }
+    }
+
+    // after ',' param is mandatory
+    if (comma_found) {
+      continue;
+    }
+
+    if (state.index >= state.max) {
+      break;
+    }
+
+    // Stop on next segment
+    if (!isDigitStart(state.path.charCodeAt(state.index))) {
+      break;
+    }
+  }
+
+  finalizeSegment(state);
+}
+
+
+/* Returns array of segments:
+ *
+ * [
+ *   [ command, coord1, coord2, ... ]
+ * ]
+ */
+module.exports = function pathParse(svgPath) {
+  var state = new State(svgPath);
+  var max = state.max;
+
+  skipSpaces(state);
+
+  while (state.index < max && !state.err.length) {
+    scanSegment(state);
+  }
+
+  if (state.err.length) {
+    state.result = [];
+
+  } else if (state.result.length) {
+
+    if ('mM'.indexOf(state.result[0][0]) < 0) {
+      state.err = 'SvgPath: string should start with `M` or `m`';
+      state.result = [];
+    } else {
+      state.result[0][0] = 'M';
+    }
+  }
+
+  return {
+    err: state.err,
+    segments: state.result
+  };
+};
+
+},{}],6:[function(require,module,exports){
+// SVG Path transformations library
+//
+// Usage:
+//
+//    SvgPath('...')
+//      .translate(-150, -100)
+//      .scale(0.5)
+//      .translate(-150, -100)
+//      .toFixed(1)
+//      .toString()
+//
+
+'use strict';
+
+
+var pathParse      = require('./path_parse');
+var transformParse = require('./transform_parse');
+var matrix         = require('./matrix');
+var a2c            = require('./a2c');
+var ellipse        = require('./ellipse');
+
+
+// Class constructor
+//
+function SvgPath(path) {
+  if (!(this instanceof SvgPath)) { return new SvgPath(path); }
+
+  var pstate = pathParse(path);
+
+  // Array of path segments.
+  // Each segment is array [command, param1, param2, ...]
+  this.segments = pstate.segments;
+
+  // Error message on parse error.
+  this.err      = pstate.err;
+
+  // Transforms stack for lazy evaluation
+  this.__stack    = [];
+}
+
+
+SvgPath.prototype.__matrix = function (m) {
+  var self = this, i;
+
+  // Quick leave for empty matrix
+  if (!m.queue.length) { return; }
+
+  this.iterate(function (s, index, x, y) {
+    var p, result, name, isRelative;
+
+    switch (s[0]) {
+
+      // Process 'assymetric' commands separately
+      case 'v':
+        p      = m.calc(0, s[1], true);
+        result = (p[0] === 0) ? [ 'v', p[1] ] : [ 'l', p[0], p[1] ];
+        break;
+
+      case 'V':
+        p      = m.calc(x, s[1], false);
+        result = (p[0] === m.calc(x, y, false)[0]) ? [ 'V', p[1] ] : [ 'L', p[0], p[1] ];
+        break;
+
+      case 'h':
+        p      = m.calc(s[1], 0, true);
+        result = (p[1] === 0) ? [ 'h', p[0] ] : [ 'l', p[0], p[1] ];
+        break;
+
+      case 'H':
+        p      = m.calc(s[1], y, false);
+        result = (p[1] === m.calc(x, y, false)[1]) ? [ 'H', p[0] ] : [ 'L', p[0], p[1] ];
+        break;
+
+      case 'a':
+      case 'A':
+        // ARC is: ['A', rx, ry, x-axis-rotation, large-arc-flag, sweep-flag, x, y]
+
+        // Drop segment if arc is empty (end point === start point)
+        /*if ((s[0] === 'A' && s[6] === x && s[7] === y) ||
+            (s[0] === 'a' && s[6] === 0 && s[7] === 0)) {
+          return [];
+        }*/
+
+        // Transform rx, ry and the x-axis-rotation
+        var ma = m.toArray();
+        var e = ellipse(s[1], s[2], s[3]).transform(ma);
+
+        // flip sweep-flag if matrix is not orientation-preserving
+        if (ma[0] * ma[3] - ma[1] * ma[2] < 0) {
+          s[5] = s[5] ? '0' : '1';
+        }
+
+        // Transform end point as usual (without translation for relative notation)
+        p = m.calc(s[6], s[7], s[0] === 'a');
+
+        // Empty arcs can be ignored by renderer, but should not be dropped
+        // to avoid collisions with `S A S` and so on. Replace with empty line.
+        if ((s[0] === 'A' && s[6] === x && s[7] === y) ||
+            (s[0] === 'a' && s[6] === 0 && s[7] === 0)) {
+          result = [ s[0] === 'a' ? 'l' : 'L', p[0], p[1] ];
+          break;
+        }
+
+        // if the resulting ellipse is (almost) a segment ...
+        if (e.isDegenerate()) {
+          // replace the arc by a line
+          result = [ s[0] === 'a' ? 'l' : 'L', p[0], p[1] ];
+        } else {
+          // if it is a real ellipse
+          // s[0], s[4] and s[5] are not modified
+          result = [ s[0], e.rx, e.ry, e.ax, s[4], s[5], p[0], p[1] ];
+        }
+
+        break;
+
+      case 'm':
+        // Edge case. The very first `m` should be processed as absolute, if happens.
+        // Make sense for coord shift transforms.
+        isRelative = index > 0;
+
+        p = m.calc(s[1], s[2], isRelative);
+        result = [ 'm', p[0], p[1] ];
+        break;
+
+      default:
+        name       = s[0];
+        result     = [ name ];
+        isRelative = (name.toLowerCase() === name);
+
+        // Apply transformations to the segment
+        for (i = 1; i < s.length; i += 2) {
+          p = m.calc(s[i], s[i + 1], isRelative);
+          result.push(p[0], p[1]);
+        }
+    }
+
+    self.segments[index] = result;
+  }, true);
+};
+
+
+// Apply stacked commands
+//
+SvgPath.prototype.__evaluateStack = function () {
+  var m, i;
+
+  if (!this.__stack.length) { return; }
+
+  if (this.__stack.length === 1) {
+    this.__matrix(this.__stack[0]);
+    this.__stack = [];
+    return;
+  }
+
+  m = matrix();
+  i = this.__stack.length;
+
+  while (--i >= 0) {
+    m.matrix(this.__stack[i].toArray());
+  }
+
+  this.__matrix(m);
+  this.__stack = [];
+};
+
+
+// Convert processed SVG Path back to string
+//
+SvgPath.prototype.toString = function () {
+  var elements = [], skipCmd, cmd;
+
+  this.__evaluateStack();
+
+  for (var i = 0; i < this.segments.length; i++) {
+    // remove repeating commands names
+    cmd = this.segments[i][0];
+    skipCmd = i > 0 && cmd !== 'm' && cmd !== 'M' && cmd === this.segments[i - 1][0];
+    elements = elements.concat(skipCmd ? this.segments[i].slice(1) : this.segments[i]);
+  }
+
+  return elements.join(' ')
+            // Optimizations: remove spaces around commands & before `-`
+            //
+            // We could also remove leading zeros for `0.5`-like values,
+            // but their count is too small to spend time for.
+            .replace(/ ?([achlmqrstvz]) ?/gi, '$1')
+            .replace(/ \-/g, '-')
+            // workaround for FontForge SVG importing bug
+            .replace(/zm/g, 'z m');
+};
+
+
+// Translate path to (x [, y])
+//
+SvgPath.prototype.translate = function (x, y) {
+  this.__stack.push(matrix().translate(x, y || 0));
+  return this;
+};
+
+
+// Scale path to (sx [, sy])
+// sy = sx if not defined
+//
+SvgPath.prototype.scale = function (sx, sy) {
+  this.__stack.push(matrix().scale(sx, (!sy && (sy !== 0)) ? sx : sy));
+  return this;
+};
+
+
+// Rotate path around point (sx [, sy])
+// sy = sx if not defined
+//
+SvgPath.prototype.rotate = function (angle, rx, ry) {
+  this.__stack.push(matrix().rotate(angle, rx || 0, ry || 0));
+  return this;
+};
+
+
+// Skew path along the X axis by `degrees` angle
+//
+SvgPath.prototype.skewX = function (degrees) {
+  this.__stack.push(matrix().skewX(degrees));
+  return this;
+};
+
+
+// Skew path along the Y axis by `degrees` angle
+//
+SvgPath.prototype.skewY = function (degrees) {
+  this.__stack.push(matrix().skewY(degrees));
+  return this;
+};
+
+
+// Apply matrix transform (array of 6 elements)
+//
+SvgPath.prototype.matrix = function (m) {
+  this.__stack.push(matrix().matrix(m));
+  return this;
+};
+
+
+// Transform path according to "transform" attr of SVG spec
+//
+SvgPath.prototype.transform = function (transformString) {
+  if (!transformString.trim()) {
+    return this;
+  }
+  this.__stack.push(transformParse(transformString));
+  return this;
+};
+
+
+// Round coords with given decimal precition.
+// 0 by default (to integers)
+//
+SvgPath.prototype.round = function (d) {
+  var contourStartDeltaX = 0, contourStartDeltaY = 0, deltaX = 0, deltaY = 0, l;
+
+  d = d || 0;
+
+  this.__evaluateStack();
+
+  this.segments.forEach(function (s) {
+    var isRelative = (s[0].toLowerCase() === s[0]);
+
+    switch (s[0]) {
+      case 'H':
+      case 'h':
+        if (isRelative) { s[1] += deltaX; }
+        deltaX = s[1] - s[1].toFixed(d);
+        s[1] = +s[1].toFixed(d);
+        return;
+
+      case 'V':
+      case 'v':
+        if (isRelative) { s[1] += deltaY; }
+        deltaY = s[1] - s[1].toFixed(d);
+        s[1] = +s[1].toFixed(d);
+        return;
+
+      case 'Z':
+      case 'z':
+        deltaX = contourStartDeltaX;
+        deltaY = contourStartDeltaY;
+        return;
+
+      case 'M':
+      case 'm':
+        if (isRelative) {
+          s[1] += deltaX;
+          s[2] += deltaY;
+        }
+
+        deltaX = s[1] - s[1].toFixed(d);
+        deltaY = s[2] - s[2].toFixed(d);
+
+        contourStartDeltaX = deltaX;
+        contourStartDeltaY = deltaY;
+
+        s[1] = +s[1].toFixed(d);
+        s[2] = +s[2].toFixed(d);
+        return;
+
+      case 'A':
+      case 'a':
+        // [cmd, rx, ry, x-axis-rotation, large-arc-flag, sweep-flag, x, y]
+        if (isRelative) {
+          s[6] += deltaX;
+          s[7] += deltaY;
+        }
+
+        deltaX = s[6] - s[6].toFixed(d);
+        deltaY = s[7] - s[7].toFixed(d);
+
+        s[1] = +s[1].toFixed(d);
+        s[2] = +s[2].toFixed(d);
+        s[3] = +s[3].toFixed(d + 2); // better precision for rotation
+        s[6] = +s[6].toFixed(d);
+        s[7] = +s[7].toFixed(d);
+        return;
+
+      default:
+        // a c l q s t
+        l = s.length;
+
+        if (isRelative) {
+          s[l - 2] += deltaX;
+          s[l - 1] += deltaY;
+        }
+
+        deltaX = s[l - 2] - s[l - 2].toFixed(d);
+        deltaY = s[l - 1] - s[l - 1].toFixed(d);
+
+        s.forEach(function (val, i) {
+          if (!i) { return; }
+          s[i] = +s[i].toFixed(d);
+        });
+        return;
+    }
+  });
+
+  return this;
+};
+
+
+// Apply iterator function to all segments. If function returns result,
+// current segment will be replaced to array of returned segments.
+// If empty array is returned, current regment will be deleted.
+//
+SvgPath.prototype.iterate = function (iterator, keepLazyStack) {
+  var segments = this.segments,
+      replacements = {},
+      needReplace = false,
+      lastX = 0,
+      lastY = 0,
+      countourStartX = 0,
+      countourStartY = 0;
+  var i, j, newSegments;
+
+  if (!keepLazyStack) {
+    this.__evaluateStack();
+  }
+
+  segments.forEach(function (s, index) {
+
+    var res = iterator(s, index, lastX, lastY);
+
+    if (Array.isArray(res)) {
+      replacements[index] = res;
+      needReplace = true;
+    }
+
+    var isRelative = (s[0] === s[0].toLowerCase());
+
+    // calculate absolute X and Y
+    switch (s[0]) {
+      case 'm':
+      case 'M':
+        lastX = s[1] + (isRelative ? lastX : 0);
+        lastY = s[2] + (isRelative ? lastY : 0);
+        countourStartX = lastX;
+        countourStartY = lastY;
+        return;
+
+      case 'h':
+      case 'H':
+        lastX = s[1] + (isRelative ? lastX : 0);
+        return;
+
+      case 'v':
+      case 'V':
+        lastY = s[1] + (isRelative ? lastY : 0);
+        return;
+
+      case 'z':
+      case 'Z':
+        // That make sence for multiple contours
+        lastX = countourStartX;
+        lastY = countourStartY;
+        return;
+
+      default:
+        lastX = s[s.length - 2] + (isRelative ? lastX : 0);
+        lastY = s[s.length - 1] + (isRelative ? lastY : 0);
+    }
+  });
+
+  // Replace segments if iterator return results
+
+  if (!needReplace) { return this; }
+
+  newSegments = [];
+
+  for (i = 0; i < segments.length; i++) {
+    if (typeof replacements[i] !== 'undefined') {
+      for (j = 0; j < replacements[i].length; j++) {
+        newSegments.push(replacements[i][j]);
+      }
+    } else {
+      newSegments.push(segments[i]);
+    }
+  }
+
+  this.segments = newSegments;
+
+  return this;
+};
+
+
+// Converts segments from relative to absolute
+//
+SvgPath.prototype.abs = function () {
+
+  this.iterate(function (s, index, x, y) {
+    var name = s[0],
+        nameUC = name.toUpperCase(),
+        i;
+
+    // Skip absolute commands
+    if (name === nameUC) { return; }
+
+    s[0] = nameUC;
+
+    switch (name) {
+      case 'v':
+        // v has shifted coords parity
+        s[1] += y;
+        return;
+
+      case 'a':
+        // ARC is: ['A', rx, ry, x-axis-rotation, large-arc-flag, sweep-flag, x, y]
+        // touch x, y only
+        s[6] += x;
+        s[7] += y;
+        return;
+
+      default:
+        for (i = 1; i < s.length; i++) {
+          s[i] += i % 2 ? x : y; // odd values are X, even - Y
+        }
+    }
+  }, true);
+
+  return this;
+};
+
+
+// Converts segments from absolute to relative
+//
+SvgPath.prototype.rel = function () {
+
+  this.iterate(function (s, index, x, y) {
+    var name = s[0],
+        nameLC = name.toLowerCase(),
+        i;
+
+    // Skip relative commands
+    if (name === nameLC) { return; }
+
+    // Don't touch the first M to avoid potential confusions.
+    if (index === 0 && name === 'M') { return; }
+
+    s[0] = nameLC;
+
+    switch (name) {
+      case 'V':
+        // V has shifted coords parity
+        s[1] -= y;
+        return;
+
+      case 'A':
+        // ARC is: ['A', rx, ry, x-axis-rotation, large-arc-flag, sweep-flag, x, y]
+        // touch x, y only
+        s[6] -= x;
+        s[7] -= y;
+        return;
+
+      default:
+        for (i = 1; i < s.length; i++) {
+          s[i] -= i % 2 ? x : y; // odd values are X, even - Y
+        }
+    }
+  }, true);
+
+  return this;
+};
+
+
+// Converts arcs to cubic bézier curves
+//
+SvgPath.prototype.unarc = function () {
+  this.iterate(function (s, index, x, y) {
+    var new_segments, nextX, nextY, result = [], name = s[0];
+
+    // Skip anything except arcs
+    if (name !== 'A' && name !== 'a') { return null; }
+
+    if (name === 'a') {
+      // convert relative arc coordinates to absolute
+      nextX = x + s[6];
+      nextY = y + s[7];
+    } else {
+      nextX = s[6];
+      nextY = s[7];
+    }
+
+    new_segments = a2c(x, y, nextX, nextY, s[4], s[5], s[1], s[2], s[3]);
+
+    // Degenerated arcs can be ignored by renderer, but should not be dropped
+    // to avoid collisions with `S A S` and so on. Replace with empty line.
+    if (new_segments.length === 0) {
+      return [ [ s[0] === 'a' ? 'l' : 'L', s[6], s[7] ] ];
+    }
+
+    new_segments.forEach(function (s) {
+      result.push([ 'C', s[2], s[3], s[4], s[5], s[6], s[7] ]);
+    });
+
+    return result;
+  });
+
+  return this;
+};
+
+
+// Converts smooth curves (with missed control point) to generic curves
+//
+SvgPath.prototype.unshort = function () {
+  var segments = this.segments;
+  var prevControlX, prevControlY, prevSegment;
+  var curControlX, curControlY;
+
+  // TODO: add lazy evaluation flag when relative commands supported
+
+  this.iterate(function (s, idx, x, y) {
+    var name = s[0], nameUC = name.toUpperCase(), isRelative;
+
+    // First command MUST be M|m, it's safe to skip.
+    // Protect from access to [-1] for sure.
+    if (!idx) { return; }
+
+    if (nameUC === 'T') { // quadratic curve
+      isRelative = (name === 't');
+
+      prevSegment = segments[idx - 1];
+
+      if (prevSegment[0] === 'Q') {
+        prevControlX = prevSegment[1] - x;
+        prevControlY = prevSegment[2] - y;
+      } else if (prevSegment[0] === 'q') {
+        prevControlX = prevSegment[1] - prevSegment[3];
+        prevControlY = prevSegment[2] - prevSegment[4];
+      } else {
+        prevControlX = 0;
+        prevControlY = 0;
+      }
+
+      curControlX = -prevControlX;
+      curControlY = -prevControlY;
+
+      if (!isRelative) {
+        curControlX += x;
+        curControlY += y;
+      }
+
+      segments[idx] = [
+        isRelative ? 'q' : 'Q',
+        curControlX, curControlY,
+        s[1], s[2]
+      ];
+
+    } else if (nameUC === 'S') { // cubic curve
+      isRelative = (name === 's');
+
+      prevSegment = segments[idx - 1];
+
+      if (prevSegment[0] === 'C') {
+        prevControlX = prevSegment[3] - x;
+        prevControlY = prevSegment[4] - y;
+      } else if (prevSegment[0] === 'c') {
+        prevControlX = prevSegment[3] - prevSegment[5];
+        prevControlY = prevSegment[4] - prevSegment[6];
+      } else {
+        prevControlX = 0;
+        prevControlY = 0;
+      }
+
+      curControlX = -prevControlX;
+      curControlY = -prevControlY;
+
+      if (!isRelative) {
+        curControlX += x;
+        curControlY += y;
+      }
+
+      segments[idx] = [
+        isRelative ? 'c' : 'C',
+        curControlX, curControlY,
+        s[1], s[2], s[3], s[4]
+      ];
+    }
+  });
+
+  return this;
+};
+
+
+module.exports = SvgPath;
+
+},{"./a2c":2,"./ellipse":3,"./matrix":4,"./path_parse":5,"./transform_parse":7}],7:[function(require,module,exports){
+'use strict';
+
+
+var Matrix = require('./matrix');
+
+var operations = {
+  matrix: true,
+  scale: true,
+  rotate: true,
+  translate: true,
+  skewX: true,
+  skewY: true
+};
+
+var CMD_SPLIT_RE    = /\s*(matrix|translate|scale|rotate|skewX|skewY)\s*\(\s*(.+?)\s*\)[\s,]*/;
+var PARAMS_SPLIT_RE = /[\s,]+/;
+
+
+module.exports = function transformParse(transformString) {
+  var matrix = new Matrix();
+  var cmd, params;
+
+  // Split value into ['', 'translate', '10 50', '', 'scale', '2', '', 'rotate',  '-45', '']
+  transformString.split(CMD_SPLIT_RE).forEach(function (item) {
+
+    // Skip empty elements
+    if (!item.length) { return; }
+
+    // remember operation
+    if (typeof operations[item] !== 'undefined') {
+      cmd = item;
+      return;
+    }
+
+    // extract params & att operation to matrix
+    params = item.split(PARAMS_SPLIT_RE).map(function (i) {
+      return +i || 0;
+    });
+
+    // If params count is not correct - ignore command
+    switch (cmd) {
+      case 'matrix':
+        if (params.length === 6) {
+          matrix.matrix(params);
+        }
+        return;
+
+      case 'scale':
+        if (params.length === 1) {
+          matrix.scale(params[0], params[0]);
+        } else if (params.length === 2) {
+          matrix.scale(params[0], params[1]);
+        }
+        return;
+
+      case 'rotate':
+        if (params.length === 1) {
+          matrix.rotate(params[0], 0, 0);
+        } else if (params.length === 3) {
+          matrix.rotate(params[0], params[1], params[2]);
+        }
+        return;
+
+      case 'translate':
+        if (params.length === 1) {
+          matrix.translate(params[0], 0);
+        } else if (params.length === 2) {
+          matrix.translate(params[0], params[1]);
+        }
+        return;
+
+      case 'skewX':
+        if (params.length === 1) {
+          matrix.skewX(params[0]);
+        }
+        return;
+
+      case 'skewY':
+        if (params.length === 1) {
+          matrix.skewY(params[0]);
+        }
+        return;
+    }
+  });
+
+  return matrix;
+};
+
+},{"./matrix":4}],8:[function(require,module,exports){
+/*! https://mths.be/cssesc v1.0.1 by @mathias */
+'use strict';
+
+var object = {};
+var hasOwnProperty = object.hasOwnProperty;
+var merge = function merge(options, defaults) {
+	if (!options) {
+		return defaults;
+	}
+	var result = {};
+	for (var key in defaults) {
+		// `if (defaults.hasOwnProperty(key) { … }` is not needed here, since
+		// only recognized option names are used.
+		result[key] = hasOwnProperty.call(options, key) ? options[key] : defaults[key];
+	}
+	return result;
+};
+
+var regexAnySingleEscape = /[ -,\.\/;-@\[-\^`\{-~]/;
+var regexSingleEscape = /[ -,\.\/;-@\[\]\^`\{-~]/;
+var regexAlwaysEscape = /['"\\]/;
+var regexExcessiveSpaces = /(^|\\+)?(\\[A-F0-9]{1,6})\x20(?![a-fA-F0-9\x20])/g;
+
+// https://mathiasbynens.be/notes/css-escapes#css
+var cssesc = function cssesc(string, options) {
+	options = merge(options, cssesc.options);
+	if (options.quotes != 'single' && options.quotes != 'double') {
+		options.quotes = 'single';
+	}
+	var quote = options.quotes == 'double' ? '"' : '\'';
+	var isIdentifier = options.isIdentifier;
+
+	var firstChar = string.charAt(0);
+	var output = '';
+	var counter = 0;
+	var length = string.length;
+	while (counter < length) {
+		var character = string.charAt(counter++);
+		var codePoint = character.charCodeAt();
+		var value = void 0;
+		// If it’s not a printable ASCII character…
+		if (codePoint < 0x20 || codePoint > 0x7E) {
+			if (codePoint >= 0xD800 && codePoint <= 0xDBFF && counter < length) {
+				// It’s a high surrogate, and there is a next character.
+				var extra = string.charCodeAt(counter++);
+				if ((extra & 0xFC00) == 0xDC00) {
+					// next character is low surrogate
+					codePoint = ((codePoint & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000;
+				} else {
+					// It’s an unmatched surrogate; only append this code unit, in case
+					// the next code unit is the high surrogate of a surrogate pair.
+					counter--;
+				}
+			}
+			value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
+		} else {
+			if (options.escapeEverything) {
+				if (regexAnySingleEscape.test(character)) {
+					value = '\\' + character;
+				} else {
+					value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
+				}
+				// Note: `:` could be escaped as `\:`, but that fails in IE < 8.
+			} else if (/[\t\n\f\r\x0B:]/.test(character)) {
+				if (!isIdentifier && character == ':') {
+					value = character;
+				} else {
+					value = '\\' + codePoint.toString(16).toUpperCase() + ' ';
+				}
+			} else if (character == '\\' || !isIdentifier && (character == '"' && quote == character || character == '\'' && quote == character) || isIdentifier && regexSingleEscape.test(character)) {
+				value = '\\' + character;
+			} else {
+				value = character;
+			}
+		}
+		output += value;
+	}
+
+	if (isIdentifier) {
+		if (/^_/.test(output)) {
+			// Prevent IE6 from ignoring the rule altogether (in case this is for an
+			// identifier used as a selector)
+			output = '\\_' + output.slice(1);
+		} else if (/^-[-\d]/.test(output)) {
+			output = '\\-' + output.slice(1);
+		} else if (/\d/.test(firstChar)) {
+			output = '\\3' + firstChar + ' ' + output.slice(1);
+		}
+	}
+
+	// Remove spaces after `\HEX` escapes that are not followed by a hex digit,
+	// since they’re redundant. Note that this is only possible if the escape
+	// sequence isn’t preceded by an odd number of backslashes.
+	output = output.replace(regexExcessiveSpaces, function ($0, $1, $2) {
+		if ($1 && $1.length % 2) {
+			// It’s not safe to remove the space, so don’t.
+			return $0;
+		}
+		// Strip the space.
+		return ($1 || '') + $2;
+	});
+
+	if (!isIdentifier && options.wrap) {
+		return quote + output + quote;
+	}
+	return output;
+};
+
+// Expose default options (so they can be overridden globally).
+cssesc.options = {
+	'escapeEverything': false,
+	'isIdentifier': false,
+	'quotes': 'single',
+	'wrap': false
+};
+
+cssesc.version = '1.0.1';
+
+module.exports = cssesc;
+
+},{}],9:[function(require,module,exports){
+// parse
+// =====
+
+// states
+// ------
+
+var PLAIN      = 0;
+var STRINGS    = 1;
+var ESCAPING   = 2;
+var IDENTIFIER = 3;
+var SEPARATING = 4;
+
+// patterns
+// --------
+
+var identifierPattern = /[a-z0-9_-]/i;
+var spacePattern      = /[\s\t]/;
+
+// ---
+
+var parse = function(str) {
+
+  // vars
+  // ----
+
+  var starting = true;
+  var state    = PLAIN;
+  var buffer   = '';
+  var i        = 0;
+  var quote;
+  var c;
+
+  // result
+  // ------
+
+  var names  = [];
+
+  // parse
+  // -----
+
+  while (true) {
+
+    c = str[i];
+
+    if (state === PLAIN) {
+
+      if (!c && starting) {
+
+        break;
+
+      } else if (!c && !starting) {
+
+        throw new Error('Parse error');
+
+      } else if (c === '"' || c === "'") {
+
+        quote = c;
+        state = STRINGS;
+        starting = false;
+
+      } else if (spacePattern.test(c)) {
+      } else if (identifierPattern.test(c)) {
+
+        state = IDENTIFIER;
+        starting = false;
+        i--;
+
+      } else {
+
+        throw new Error('Parse error');
+
+      }
+
+    } else if (state === STRINGS) {
+
+      if (!c) {
+
+        throw new Error('Parse Error');
+
+      } else if (c === "\\") {
+
+        state = ESCAPING;
+
+      } else if (c === quote) {
+
+        names.push(buffer);
+        buffer = '';
+        state = SEPARATING;
+
+      } else {
+
+        buffer += c;
+
+      }
+
+    } else if (state === ESCAPING) {
+
+      if (c === quote || c === "\\") {
+
+        buffer += c;
+        state = STRINGS;
+
+      } else {
+
+        throw new Error('Parse error');
+
+      }
+
+    } else if (state === IDENTIFIER) {
+
+      if (!c) {
+
+        names.push(buffer);
+        break;
+
+      } else if (identifierPattern.test(c)) {
+
+        buffer += c;
+
+      } else if (c === ',') {
+
+        names.push(buffer);
+        buffer = '';
+        state = PLAIN;
+
+      } else if (spacePattern.test(c)) {
+
+        names.push(buffer);
+        buffer = '';
+        state = SEPARATING;
+
+      } else {
+
+        throw new Error('Parse error');
+
+      }
+
+    } else if (state === SEPARATING) {
+
+      if (!c) {
+
+        break;
+
+      } else if (c === ',') {
+
+        state = PLAIN;
+
+      } else if (spacePattern.test(c)) {
+      } else {
+
+        throw new Error('Parse error');
+
+      }
+
+    }
+
+    i++;
+
+  }
+
+  // result
+  // ------
+
+  return names;
+
+};
+
+// stringify
+// =========
+
+// pattern
+// -------
+
+var stringsPattern = /[^a-z0-9_-]/i;
+
+// ---
+
+var stringify = function(names, options) {
+
+  // quote
+  // -----
+
+  var quote = options && options.quote || '"';
+  if (quote !== '"' && quote !== "'") {
+    throw new Error('Quote must be `\'` or `"`');
+  }
+  var quotePattern = new RegExp(quote, 'g');
+
+  // stringify
+  // ---------
+
+  var safeNames = [];
+
+  for (var i = 0; i < names.length; ++i) {
+    var name = names[i];
+
+    if (stringsPattern.test(name)) {
+      name = name
+        .replace(/\\/g, "\\\\")
+        .replace(quotePattern, "\\" + quote);
+      name = quote + name + quote;
+    }
+    safeNames.push(name);
+  }
+
+  // result
+  // ------
+
+  return safeNames.join(', ');
+};
+
+// export
+// ======
+
+module.exports = {
+  parse:     parse,
+  stringify: stringify,
+};
+
+},{}],10:[function(require,module,exports){
+/**
+ * A class to parse color values
+ * @author Stoyan Stefanov <sstoo@gmail.com>
+ * @link   http://www.phpied.com/rgb-color-parser-in-javascript/
+ * @license Use it if you like it
+ */
+(function (global) {
+function RGBColor(color_string)
+{
+  this.ok = false;
+
+  // strip any leading #
+  if (color_string.charAt(0) == '#') { // remove # if any
+    color_string = color_string.substr(1,6);
+  }
+
+  color_string = color_string.replace(/ /g,'');
+  color_string = color_string.toLowerCase();
+
+  // before getting into regexps, try simple matches
+  // and overwrite the input
+  var simple_colors = {
+    aliceblue: 'f0f8ff',
+    antiquewhite: 'faebd7',
+    aqua: '00ffff',
+    aquamarine: '7fffd4',
+    azure: 'f0ffff',
+    beige: 'f5f5dc',
+    bisque: 'ffe4c4',
+    black: '000000',
+    blanchedalmond: 'ffebcd',
+    blue: '0000ff',
+    blueviolet: '8a2be2',
+    brown: 'a52a2a',
+    burlywood: 'deb887',
+    cadetblue: '5f9ea0',
+    chartreuse: '7fff00',
+    chocolate: 'd2691e',
+    coral: 'ff7f50',
+    cornflowerblue: '6495ed',
+    cornsilk: 'fff8dc',
+    crimson: 'dc143c',
+    cyan: '00ffff',
+    darkblue: '00008b',
+    darkcyan: '008b8b',
+    darkgoldenrod: 'b8860b',
+    darkgray: 'a9a9a9',
+    darkgreen: '006400',
+    darkkhaki: 'bdb76b',
+    darkmagenta: '8b008b',
+    darkolivegreen: '556b2f',
+    darkorange: 'ff8c00',
+    darkorchid: '9932cc',
+    darkred: '8b0000',
+    darksalmon: 'e9967a',
+    darkseagreen: '8fbc8f',
+    darkslateblue: '483d8b',
+    darkslategray: '2f4f4f',
+    darkturquoise: '00ced1',
+    darkviolet: '9400d3',
+    deeppink: 'ff1493',
+    deepskyblue: '00bfff',
+    dimgray: '696969',
+    dodgerblue: '1e90ff',
+    feldspar: 'd19275',
+    firebrick: 'b22222',
+    floralwhite: 'fffaf0',
+    forestgreen: '228b22',
+    fuchsia: 'ff00ff',
+    gainsboro: 'dcdcdc',
+    ghostwhite: 'f8f8ff',
+    gold: 'ffd700',
+    goldenrod: 'daa520',
+    gray: '808080',
+    green: '008000',
+    greenyellow: 'adff2f',
+    honeydew: 'f0fff0',
+    hotpink: 'ff69b4',
+    indianred : 'cd5c5c',
+    indigo : '4b0082',
+    ivory: 'fffff0',
+    khaki: 'f0e68c',
+    lavender: 'e6e6fa',
+    lavenderblush: 'fff0f5',
+    lawngreen: '7cfc00',
+    lemonchiffon: 'fffacd',
+    lightblue: 'add8e6',
+    lightcoral: 'f08080',
+    lightcyan: 'e0ffff',
+    lightgoldenrodyellow: 'fafad2',
+    lightgrey: 'd3d3d3',
+    lightgreen: '90ee90',
+    lightpink: 'ffb6c1',
+    lightsalmon: 'ffa07a',
+    lightseagreen: '20b2aa',
+    lightskyblue: '87cefa',
+    lightslateblue: '8470ff',
+    lightslategray: '778899',
+    lightsteelblue: 'b0c4de',
+    lightyellow: 'ffffe0',
+    lime: '00ff00',
+    limegreen: '32cd32',
+    linen: 'faf0e6',
+    magenta: 'ff00ff',
+    maroon: '800000',
+    mediumaquamarine: '66cdaa',
+    mediumblue: '0000cd',
+    mediumorchid: 'ba55d3',
+    mediumpurple: '9370d8',
+    mediumseagreen: '3cb371',
+    mediumslateblue: '7b68ee',
+    mediumspringgreen: '00fa9a',
+    mediumturquoise: '48d1cc',
+    mediumvioletred: 'c71585',
+    midnightblue: '191970',
+    mintcream: 'f5fffa',
+    mistyrose: 'ffe4e1',
+    moccasin: 'ffe4b5',
+    navajowhite: 'ffdead',
+    navy: '000080',
+    oldlace: 'fdf5e6',
+    olive: '808000',
+    olivedrab: '6b8e23',
+    orange: 'ffa500',
+    orangered: 'ff4500',
+    orchid: 'da70d6',
+    palegoldenrod: 'eee8aa',
+    palegreen: '98fb98',
+    paleturquoise: 'afeeee',
+    palevioletred: 'd87093',
+    papayawhip: 'ffefd5',
+    peachpuff: 'ffdab9',
+    peru: 'cd853f',
+    pink: 'ffc0cb',
+    plum: 'dda0dd',
+    powderblue: 'b0e0e6',
+    purple: '800080',
+    red: 'ff0000',
+    rosybrown: 'bc8f8f',
+    royalblue: '4169e1',
+    saddlebrown: '8b4513',
+    salmon: 'fa8072',
+    sandybrown: 'f4a460',
+    seagreen: '2e8b57',
+    seashell: 'fff5ee',
+    sienna: 'a0522d',
+    silver: 'c0c0c0',
+    skyblue: '87ceeb',
+    slateblue: '6a5acd',
+    slategray: '708090',
+    snow: 'fffafa',
+    springgreen: '00ff7f',
+    steelblue: '4682b4',
+    tan: 'd2b48c',
+    teal: '008080',
+    thistle: 'd8bfd8',
+    tomato: 'ff6347',
+    turquoise: '40e0d0',
+    violet: 'ee82ee',
+    violetred: 'd02090',
+    wheat: 'f5deb3',
+    white: 'ffffff',
+    whitesmoke: 'f5f5f5',
+    yellow: 'ffff00',
+    yellowgreen: '9acd32'
+  };
+  for (var key in simple_colors) {
+    if (color_string == key) {
+      color_string = simple_colors[key];
+    }
+  }
+  // emd of simple type-in colors
+
+  // array of color definition objects
+  var color_defs = [
+    {
+      re: /^rgb\((\d{1,3}),\s*(\d{1,3}),\s*(\d{1,3})\)$/,
+      example: ['rgb(123, 234, 45)', 'rgb(255,234,245)'],
+      process: function (bits){
+        return [
+          parseInt(bits[1]),
+          parseInt(bits[2]),
+          parseInt(bits[3])
+        ];
+      }
+    },
+    {
+      re: /^(\w{2})(\w{2})(\w{2})$/,
+      example: ['#00ff00', '336699'],
+      process: function (bits){
+        return [
+          parseInt(bits[1], 16),
+          parseInt(bits[2], 16),
+          parseInt(bits[3], 16)
+        ];
+      }
+    },
+    {
+      re: /^(\w{1})(\w{1})(\w{1})$/,
+      example: ['#fb0', 'f0f'],
+      process: function (bits){
+        return [
+          parseInt(bits[1] + bits[1], 16),
+          parseInt(bits[2] + bits[2], 16),
+          parseInt(bits[3] + bits[3], 16)
+        ];
+      }
+    }
+  ];
+
+  // search through the definitions to find a match
+  for (var i = 0; i < color_defs.length; i++) {
+    var re = color_defs[i].re;
+    var processor = color_defs[i].process;
+    var bits = re.exec(color_string);
+    if (bits) {
+      var channels = processor(bits);
+      this.r = channels[0];
+      this.g = channels[1];
+      this.b = channels[2];
+      this.ok = true;
+    }
+
+  }
+
+  // validate/cleanup values
+  this.r = (this.r < 0 || isNaN(this.r)) ? 0 : ((this.r > 255) ? 255 : this.r);
+  this.g = (this.g < 0 || isNaN(this.g)) ? 0 : ((this.g > 255) ? 255 : this.g);
+  this.b = (this.b < 0 || isNaN(this.b)) ? 0 : ((this.b > 255) ? 255 : this.b);
+
+  // some getters
+  this.toRGB = function () {
+    return 'rgb(' + this.r + ', ' + this.g + ', ' + this.b + ')';
+  }
+  this.toHex = function () {
+    var r = this.r.toString(16);
+    var g = this.g.toString(16);
+    var b = this.b.toString(16);
+    if (r.length == 1) r = '0' + r;
+    if (g.length == 1) g = '0' + g;
+    if (b.length == 1) b = '0' + b;
+    return '#' + r + g + b;
+  }
+
+  // help
+  this.getHelpXML = function () {
+
+    var examples = new Array();
+    // add regexps
+    for (var i = 0; i < color_defs.length; i++) {
+      var example = color_defs[i].example;
+      for (var j = 0; j < example.length; j++) {
+        examples[examples.length] = example[j];
+      }
+    }
+    // add type-in colors
+    for (var sc in simple_colors) {
+      examples[examples.length] = sc;
+    }
+
+    var xml = document.createElement('ul');
+    xml.setAttribute('id', 'rgbcolor-examples');
+    for (var i = 0; i < examples.length; i++) {
+      try {
+        var list_item = document.createElement('li');
+        var list_color = new RGBColor(examples[i]);
+        var example_div = document.createElement('div');
+        example_div.style.cssText =
+            'margin: 3px; '
+            + 'border: 1px solid black; '
+            + 'background:' + list_color.toHex() + '; '
+            + 'color:' + list_color.toHex()
+        ;
+        example_div.appendChild(document.createTextNode('test'));
+        var list_item_value = document.createTextNode(
+            ' ' + examples[i] + ' -> ' + list_color.toRGB() + ' -> ' + list_color.toHex()
+        );
+        list_item.appendChild(example_div);
+        list_item.appendChild(list_item_value);
+        xml.appendChild(list_item);
+
+      } catch(e){}
+    }
+    return xml;
+
+  }
+
+}
+if (typeof define === "function" && define.amd) {
+  define(function () {
+    return RGBColor;
+  });
+} else if (typeof module !== "undefined" && module.exports) {
+  module.exports = RGBColor;
+} else {
+  global.RGBColor = RGBColor;
+}
+return RGBColor;
+})(typeof self !== "undefined" && self || typeof window !== "undefined" && window || this);
+
+},{}],11:[function(require,module,exports){
+/*
+The MIT License (MIT)
+
+Copyright (c) 2015-2017 yWorks GmbH
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+/**
+ * Renders an svg element to a jsPDF document.
+ * For accurate results a DOM document is required (mainly used for text size measurement and image format conversion)
+ * @param element {HTMLElement} The svg element, which will be cloned, so the original stays unchanged.
+ * @param pdf {jsPDF} The jsPDF object.
+ * @param options {object} An object that may contain render options. Currently supported are:
+ *                         scale: The global factor by which everything is scaled.
+ *                         xOffset, yOffset: Offsets that are added to every coordinate AFTER scaling (They are not
+ *                            influenced by the scale attribute).
+ */
+(function (global) {
+  var RGBColor;
+  var SvgPath;
+  var FontFamily;
+  var cssEsc;
+
+  var _pdf; // jsPDF pdf-document
+
+  var cToQ = 2 / 3; // ratio to convert quadratic bezier curves to cubic ones
+
+  var iriReference = /url\(["']?#([^"']+)["']?\)/;
+
+  // groups: 1: mime-type (+ charset), 2: mime-type (w/o charset), 3: charset, 4: base64?, 5: body
+  var dataUrlRegex = /^\s*data:(([^/,;]+\/[^/,;]+)(?:;([^,;=]+=[^,;=]+))?)?(?:;(base64))?,(.*\s*)$/i;
+
+  var svgNamespaceURI = "http://www.w3.org/2000/svg";
+
+
+  // pathSegList is marked deprecated in chrome, so parse the d attribute manually if necessary
+  var getPathSegList = function (node) {
+    var d = node.getAttribute("d");
+
+    // Replace arcs before path segment list is handled
+    if (SvgPath) {
+      d = SvgPath(d).unshort().unarc().abs().toString();
+      node.setAttribute('d', d);
+    }
+
+    var pathSegList = node.pathSegList;
+    
+    if (pathSegList) {
+      return pathSegList;
+    }
+
+    pathSegList = [];
+
+    var regex = /([a-df-zA-DF-Z])([^a-df-zA-DF-Z]*)/g,
+        match;
+    while (match = regex.exec(d)) {
+      var coords = parseFloats(match[2]);
+
+      var type = match[1];
+      var length = "zZ".indexOf(type) >= 0 ? 0 :
+          "hHvV".indexOf(type) >= 0  ? 1 :
+          "mMlLtT".indexOf(type) >= 0  ? 2 :
+          "sSqQ".indexOf(type) >= 0  ? 4 :
+          "aA".indexOf(type) >= 0  ? 7 :
+          "cC".indexOf(type) >= 0  ? 6 : -1;
+
+      var i = 0;
+      do {
+        var pathSeg = {pathSegTypeAsLetter: type};
+        switch (type) {
+          case "h":
+          case "H":
+            pathSeg.x = coords[i];
+            break;
+
+          case "v":
+          case "V":
+            pathSeg.y = coords[i];
+            break;
+
+          case "c":
+          case "C":
+            pathSeg.x1 = coords[i + length - 6];
+            pathSeg.y1 = coords[i + length - 5];
+          case "s":
+          case "S":
+            pathSeg.x2 = coords[i + length - 4];
+            pathSeg.y2 = coords[i + length - 3];
+          case "t":
+          case "T":
+          case "l":
+          case "L":
+          case "m":
+          case "M":
+            pathSeg.x = coords[i + length - 2];
+            pathSeg.y = coords[i + length - 1];
+            break;
+
+          case "q":
+          case "Q":
+            pathSeg.x1 = coords[i];
+            pathSeg.y1 = coords[i + 1];
+            pathSeg.x = coords[i + 2];
+            pathSeg.y = coords[i + 3];
+            break;
+          case "a":
+          case "A":
+            throw new Error("Cannot convert Arcs without SvgPath package");
+        }
+
+        pathSegList.push(pathSeg);
+
+        // "If a moveto is followed by multiple pairs of coordinates, the subsequent pairs are treated as implicit
+        // lineto commands"
+        if (type === "m") {
+          type = "l";
+        } else if (type === "M") {
+          type = "L";
+        }
+
+        i += length;
+      } while(i < coords.length);
+    }
+
+    pathSegList.getItem = function (i) {
+      return this[i]
+    };
+    pathSegList.numberOfItems = pathSegList.length;
+
+    return pathSegList;
+  };
+
+  // returns an attribute of a node, either from the node directly or from css
+  var getAttribute = function (node, propertyNode, propertyCss) {
+    propertyCss = propertyCss || propertyNode;
+    return node.getAttribute(propertyNode) || node.style && node.style[propertyCss];
+  };
+
+  /**
+   * @param {Element} node
+   * @param {string} tagsString
+   * @return {boolean}
+   */
+  var nodeIs = function (node, tagsString) {
+    return tagsString.split(",").indexOf(node.tagName.toLowerCase()) >= 0;
+  };
+
+  var forEachChild = function (node, fn) {
+    // copy list of children, as the original might be modified
+    var children = [];
+    for (var i = 0; i < node.childNodes.length; i++) {
+      var childNode = node.childNodes[i];
+      if (childNode.nodeName.charAt(0) !== "#")
+        children.push(childNode);
+    }
+    for (i = 0; i < children.length; i++) {
+      fn(i, children[i]);
+    }
+  };
+
+  var getAngle = function (from, to) {
+    return Math.atan2(to[1] - from[1], to[0] - from[0]);
+  };
+
+  function normalize(v) {
+    var length = Math.sqrt(v[0] * v[0] + v[1] * v[1]);
+    return [v[0] / length, v[1] / length];
+  }
+
+  function getDirectionVector(from, to) {
+    var v = [to[0] - from[0], to[1] - from[1]];
+    return normalize(v);
+  }
+
+  function addVectors(v1, v2) {
+    return [v1[0] + v2[0], v1[1] + v2[1]];
+  }
+
+  // mirrors p1 at p2
+  var mirrorPoint = function (p1, p2) {
+    var dx = p2[0] - p1[0];
+    var dy = p2[1] - p1[1];
+
+    return [p1[0] + 2 * dx, p1[1] + 2 * dy];
+  };
+
+  // transforms a cubic bezier control point to a quadratic one: returns from + (2/3) * (to - from)
+  var toCubic = function (from, to) {
+    return [cToQ * (to[0] - from[0]) + from[0], cToQ * (to[1] - from[1]) + from[1]];
+  };
+
+  // extracts a control point from a previous path segment (for t,T,s,S segments)
+  var getControlPointFromPrevious = function (i, from, list, prevX, prevY) {
+    var prev = list.getItem(i - 1);
+    var p2;
+    if (i > 0 && (prev.pathSegTypeAsLetter === "C" || prev.pathSegTypeAsLetter === "S")) {
+      p2 = mirrorPoint([prev.x2, prev.y2], from);
+    } else if (i > 0 && (prev.pathSegTypeAsLetter === "c" || prev.pathSegTypeAsLetter === "s")) {
+      p2 = mirrorPoint([prev.x2 + prevX, prev.y2 + prevY], from);
+    } else {
+      p2 = [from[0], from[1]];
+    }
+    return p2;
+  };
+
+  /**
+   * @param {Element} rootSvg
+   * @constructor
+   * @property {Object.<String,Element>} renderedElements
+   * @property {Element} rootSvg
+   */
+  function ReferencesHandler(rootSvg) {
+    this.renderedElements = {};
+    this.rootSvg = rootSvg;
+  }
+
+  /**
+   * @param {string} id
+   * @return {*}
+   */
+  ReferencesHandler.prototype.getRendered = function (id) {
+    if (this.renderedElements.hasOwnProperty(id)) {
+      return this.renderedElements[id];
+    }
+
+    var node = this.rootSvg.querySelector("#" + cssEsc(id, {isIdentifier: true}));
+
+    if (nodeIs(node, "lineargradient")) {
+      putGradient(node, "axial", [
+        node.getAttribute("x1") || 0,
+        node.getAttribute("y1") || 0,
+        node.getAttribute("x2") || 1,
+        node.getAttribute("y2") || 0
+      ]);
+    } else if (nodeIs(node, "radialgradient")) {
+      putGradient(node, "radial", [
+        node.getAttribute("fx") || node.getAttribute("cx") || 0.5,
+        node.getAttribute("fy") || node.getAttribute("cy") || 0.5,
+        0,
+        node.getAttribute("cx") || 0.5,
+        node.getAttribute("cy") || 0.5,
+        node.getAttribute("r") || 0.5
+      ]);
+    } else if (nodeIs(node, "pattern")) {
+      pattern(node, this, AttributeState.default())
+    } else if (nodeIs(node, "marker")) {
+      // the transformations directly at the node are written to the pdf form object transformation matrix
+      var tfMatrix = computeNodeTransform(node);
+      var bBox = getUntransformedBBox(node);
+
+      _pdf.beginFormObject(bBox[0], bBox[1], bBox[2], bBox[3], tfMatrix);
+      renderChildren(node, _pdf.unitMatrix, this, false, false, AttributeState.default());
+      _pdf.endFormObject(node.getAttribute("id"));
+    } else if (!nodeIs(node, "clippath")) {
+      // all other nodes will be rendered as PDF form object
+      renderNode(node, _pdf.unitMatrix, this, true, false, AttributeState.default());
+    }
+
+    this.renderedElements[id] = node;
+    return node;
+  };
+
+  var AttributeState = function () {
+    this.xmlSpace = null;
+    this.color = null;
+    this.fill = null;
+    this.fillOpacity = 1.0;
+    // this.fillRule = null;
+    this.fontFamily = null;
+    this.fontSize = 16;
+    this.fontStyle = null;
+    // this.fontVariant = null;
+    this.fontWeight = null;
+    this.opacity = 1.0;
+    this.stroke = null;
+    this.strokeDasharray = null;
+    this.strokeDashoffset = null;
+    this.strokeLinecap = null;
+    this.strokeLinejoin = null;
+    this.strokeMiterlimit = 4.0;
+    this.strokeOpacity = 1.0;
+    this.strokeWidth = 1.0;
+    // this.textAlign = null;
+    this.textAnchor = null;
+    this.visibility = null;
+  };
+
+  AttributeState.default = function () {
+    var attributeState = new AttributeState();
+
+    attributeState.xmlSpace = "default";
+    attributeState.fill = new RGBColor("rgb(0, 0, 0)");
+    attributeState.fillOpacity = 1.0;
+    // attributeState.fillRule = "nonzero";
+    attributeState.fontFamily = "times";
+    attributeState.fontSize = 16;
+    attributeState.fontStyle = "normal";
+    // attributeState.fontVariant = "normal";
+    attributeState.fontWeight = "normal";
+    attributeState.opacity = 1.0;
+    attributeState.stroke = null;
+    attributeState.strokeDasharray = null;
+    attributeState.strokeDashoffset = null;
+    attributeState.strokeLinecap = "butt";
+    attributeState.strokeLinejoin = "miter";
+    attributeState.strokeMiterlimit = 4.0;
+    attributeState.strokeOpacity = 1.0;
+    attributeState.strokeWidth = 1.0;
+    // attributeState.textAlign = "start";
+    attributeState.textAnchor = "start";
+    attributeState.visibility = "visible";
+
+    return attributeState;
+  };
+
+  AttributeState.prototype.clone = function () {
+    var clone = new AttributeState();
+
+    clone.xmlSpace = this.xmlSpace;
+    clone.fill = this.fill;
+    clone.fillOpacity = this.fillOpacity;
+    // clone.fillRule = this.fillRule;
+    clone.fontFamily = this.fontFamily;
+    clone.fontSize = this.fontSize;
+    clone.fontStyle = this.fontStyle;
+    // clone.fontVariant = this.fontVariant;
+    clone.fontWeight = this.fontWeight;
+    clone.opacity = this.opacity;
+    clone.stroke = this.stroke;
+    clone.strokeDasharray = this.strokeDasharray;
+    clone.strokeDashoffset = this.strokeDashoffset;
+    clone.strokeLinecap = this.strokeLinecap;
+    clone.strokeLinejoin = this.strokeLinejoin;
+    clone.strokeMiterlimit = this.strokeMiterlimit;
+    clone.strokeOpacity = this.strokeOpacity;
+    clone.strokeWidth = this.strokeWidth;
+    // clone.textAlign = this.textAlign;
+    clone.textAnchor = this.textAnchor;
+    clone.visibility = this.visibility;
+
+    return clone;
+  };
+
+  /**
+   * @constructor
+   * @property {Marker[]} markers
+   */
+  function MarkerList() {
+    this.markers = [];
+  }
+
+  /**
+   * @param {Marker} marker
+   */
+  MarkerList.prototype.addMarker = function addMarker(marker) {
+    this.markers.push(marker);
+  };
+
+  MarkerList.prototype.draw = function (tfMatrix, refsHandler, attributeState) {
+    for (var i = 0; i < this.markers.length; i++) {
+      var marker = this.markers[i];
+
+      var tf;
+      var angle = marker.angle, anchor = marker.anchor;
+      var cos = Math.cos(angle);
+      var sin = Math.sin(angle);
+      // position at and rotate around anchor
+      tf = new _pdf.Matrix(cos, sin, -sin, cos, anchor[0], anchor[1]);
+      // scale with stroke-width
+      tf = _pdf.matrixMult(new _pdf.Matrix(attributeState.strokeWidth, 0, 0, attributeState.strokeWidth, 0, 0), tf);
+
+      tf = _pdf.matrixMult(tf, tfMatrix);
+
+      // as the marker is already scaled by the current line width we must not apply the line width twice!
+      _pdf.saveGraphicsState();
+      _pdf.setLineWidth(1.0);
+      refsHandler.getRendered(marker.id);
+      _pdf.doFormObject(marker.id, tf);
+      _pdf.restoreGraphicsState();
+    }
+  };
+
+  /**
+   * @param {string} id
+   * @param {[number,number]} anchor
+   * @param {number} angle
+   */
+  function Marker(id, anchor, angle) {
+    this.id = id;
+    this.anchor = anchor;
+    this.angle = angle;
+  }
+
+  function removeNewlines(str) {
+    return str.replace(/[\n\r]/g, "");
+  }
+
+  function replaceTabsBySpace(str) {
+    return str.replace(/[\t]/g, " ");
+  }
+
+  function consolidateSpaces(str) {
+    return str.replace(/ +/g, " ");
+  }
+
+  function trimLeft(str) {
+    return str.replace(/^\s+/,"");
+  }
+
+  function trimRight(str) {
+    return str.replace(/\s+$/,"");
+  }
+
+  function computeViewBoxTransform(node, viewBox, eX, eY, eWidth, eHeight) {
+    var vbX = viewBox[0];
+    var vbY = viewBox[1];
+    var vbWidth = viewBox[2];
+    var vbHeight = viewBox[3];
+
+    var scaleX = eWidth / vbWidth;
+    var scaleY = eHeight / vbHeight;
+
+    var align, meetOrSlice;
+    var preserveAspectRatio = node.getAttribute("preserveAspectRatio");
+    if (preserveAspectRatio) {
+      var alignAndMeetOrSlice = preserveAspectRatio.split(" ");
+      if (alignAndMeetOrSlice[0] === "defer") {
+        alignAndMeetOrSlice = alignAndMeetOrSlice.slice(1);
+      }
+
+      align = alignAndMeetOrSlice[0];
+      meetOrSlice = alignAndMeetOrSlice[1] || "meet";
+    } else {
+      align = "xMidYMid";
+      meetOrSlice = "meet"
+    }
+
+    if (align !== "none") {
+      if (meetOrSlice === "meet") {
+        // uniform scaling with min scale
+        scaleX = scaleY = Math.min(scaleX, scaleY);
+      } else if (meetOrSlice === "slice") {
+        // uniform scaling with max scale
+        scaleX = scaleY = Math.max(scaleX, scaleY);
+      }
+    }
+
+    var translateX = eX - (vbX * scaleX);
+    var translateY = eY - (vbY * scaleY);
+
+    if (align.indexOf("xMid") >= 0) {
+      translateX += (eWidth - vbWidth * scaleX) / 2;
+    } else if (align.indexOf("xMax") >= 0) {
+      translateX += eWidth - vbWidth * scaleX;
+    }
+
+    if (align.indexOf("yMid") >= 0) {
+      translateY += (eHeight - vbHeight * scaleY) / 2;
+    } else if (align.indexOf("yMax") >= 0) {
+      translateY += (eHeight - vbHeight * scaleY);
+    }
+
+    var translate = new _pdf.Matrix(1, 0, 0, 1, translateX, translateY);
+    var scale = new _pdf.Matrix(scaleX, 0, 0, scaleY, 0, 0);
+
+    return _pdf.matrixMult(scale, translate);
+  }
+
+  // computes the transform directly applied at the node (such as viewbox scaling and the "transform" atrribute)
+  // x,y,cx,cy,r,... are omitted
+  var computeNodeTransform = function (node) {
+    var viewBox, x, y;
+    var nodeTransform = _pdf.unitMatrix;
+    if (nodeIs(node, "svg,g")) {
+      x = parseFloat(node.getAttribute("x")) || 0;
+      y = parseFloat(node.getAttribute("y")) || 0;
+
+      viewBox = node.getAttribute("viewBox");
+      if (viewBox) {
+        var box = parseFloats(viewBox);
+        var width = parseFloat(node.getAttribute("width")) || box[2];
+        var height = parseFloat(node.getAttribute("height")) || box[3];
+        nodeTransform = computeViewBoxTransform(node, box, x, y, width, height)
+      } else {
+        nodeTransform = new _pdf.Matrix(1, 0, 0, 1, x, y);
+      }
+    } else if (nodeIs(node, "marker")) {
+      x = parseFloat(node.getAttribute("refX")) || 0;
+      y = parseFloat(node.getAttribute("refY")) || 0;
+
+      viewBox = node.getAttribute("viewBox");
+      if (viewBox) {
+        var bounds = parseFloats(viewBox);
+        bounds[0] = bounds[1] = 0; // for some reason vbX anc vbY seem to be ignored for markers
+        nodeTransform = computeViewBoxTransform(node,
+            bounds,
+            0,
+            0,
+            parseFloat(node.getAttribute("markerWidth")) || 3,
+            parseFloat(node.getAttribute("markerHeight")) || 3
+        );
+        nodeTransform = _pdf.matrixMult(new _pdf.Matrix(1, 0, 0, 1, -x, -y), nodeTransform);
+      } else {
+        nodeTransform = new _pdf.Matrix(1, 0, 0, 1, -x, -y);
+      }
+    }
+
+    var transformString = node.getAttribute("transform");
+    if (!transformString)
+      return nodeTransform;
+    else
+      return _pdf.matrixMult(nodeTransform, parseTransform(transformString));
+  };
+
+  // parses the "points" string used by polygons and returns an array of points
+  var parsePointsString = function (string) {
+    var floats = parseFloats(string);
+    var result = [];
+    for (var i = 0; i < floats.length - 1; i += 2) {
+      var x = floats[i];
+      var y = floats[i + 1];
+      result.push([x, y]);
+    }
+    return result;
+  };
+
+  // parses the "transform" string
+  var parseTransform = function (transformString) {
+    if (!transformString)
+      return _pdf.unitMatrix;
+
+    var mRegex = /^\s*matrix\(([^\)]+)\)\s*/,
+        tRegex = /^\s*translate\(([^\)]+)\)\s*/,
+        rRegex = /^\s*rotate\(([^\)]+)\)\s*/,
+        sRegex = /^\s*scale\(([^\)]+)\)\s*/,
+        sXRegex = /^\s*skewX\(([^\)]+)\)\s*/,
+        sYRegex = /^\s*skewY\(([^\)]+)\)\s*/;
+
+    var resultMatrix = _pdf.unitMatrix, m;
+
+    while (transformString.length > 0) {
+      var match = mRegex.exec(transformString);
+      if (match) {
+        m = parseFloats(match[1]);
+        resultMatrix = _pdf.matrixMult(new _pdf.Matrix(m[0], m[1], m[2], m[3], m[4], m[5]), resultMatrix);
+        transformString = transformString.substr(match[0].length);
+      }
+      match = rRegex.exec(transformString);
+      if (match) {
+        m = parseFloats(match[1]);
+        var a = Math.PI * m[0] / 180;
+        resultMatrix = _pdf.matrixMult(new _pdf.Matrix(Math.cos(a), Math.sin(a), -Math.sin(a), Math.cos(a), 0, 0), resultMatrix);
+        if (m[1] && m[2]) {
+          var t1 = new _pdf.Matrix(1, 0, 0, 1, m[1], m[2]);
+          var t2 = new _pdf.Matrix(1, 0, 0, 1, -m[1], -m[2]);
+          resultMatrix = _pdf.matrixMult(t2, _pdf.matrixMult(resultMatrix, t1));
+        }
+        transformString = transformString.substr(match[0].length);
+      }
+      match = tRegex.exec(transformString);
+      if (match) {
+        m = parseFloats(match[1]);
+        resultMatrix = _pdf.matrixMult(new _pdf.Matrix(1, 0, 0, 1, m[0], m[1] || 0), resultMatrix);
+        transformString = transformString.substr(match[0].length);
+      }
+      match = sRegex.exec(transformString);
+      if (match) {
+        m = parseFloats(match[1]);
+        if (!m[1])
+          m[1] = m[0];
+        resultMatrix = _pdf.matrixMult(new _pdf.Matrix(m[0], 0, 0, m[1], 0, 0), resultMatrix);
+        transformString = transformString.substr(match[0].length);
+      }
+      match = sXRegex.exec(transformString);
+      if (match) {
+        m = parseFloat(match[1]);
+        resultMatrix = _pdf.matrixMult(new _pdf.Matrix(1, 0, Math.tan(m), 1, 0, 0), resultMatrix);
+        transformString = transformString.substr(match[0].length);
+      }
+      match = sYRegex.exec(transformString);
+      if (match) {
+        m = parseFloat(match[1]);
+        resultMatrix = _pdf.matrixMult(new _pdf.Matrix(1, Math.tan(m), 0, 1, 0, 0), resultMatrix);
+        transformString = transformString.substr(match[0].length);
+      }
+    }
+    return resultMatrix;
+  };
+
+  // parses a comma, sign and/or whitespace separated string of floats and returns the single floats in an array
+  var parseFloats = function (str) {
+    var floats = [], match,
+        regex = /[+-]?(?:(?:\d+\.?\d*)|(?:\d*\.?\d+))(?:[eE][+-]?\d+)?/g;
+    while(match = regex.exec(str)) {
+      floats.push(parseFloat(match[0]));
+    }
+    return floats;
+  };
+
+  // extends RGBColor by rgba colors as RGBColor is not capable of it
+  var parseColor = function (colorString) {
+    if (colorString === "transparent") {
+      var transparent = new RGBColor("rgb(0,0,0)");
+      transparent.a = 0;
+      return transparent
+    }
+
+    var match = /\s*rgba\(((?:[^,\)]*,){3}[^,\)]*)\)\s*/.exec(colorString);
+    if (match) {
+      var floats = parseFloats(match[1]);
+      var color = new RGBColor("rgb(" + floats.slice(0,3).join(",") + ")");
+      color.a = floats[3];
+      return color;
+    } else {
+      return new RGBColor(colorString);
+    }
+  };
+
+  // multiplies a vector with a matrix: vec' = vec * matrix
+  var multVecMatrix = function (vec, matrix) {
+    var x = vec[0];
+    var y = vec[1];
+    return [
+      matrix.a * x + matrix.c * y + matrix.e,
+      matrix.b * x + matrix.d * y + matrix.f
+    ];
+  };
+
+  // returns the untransformed bounding box [x, y, width, height] of an svg element (quite expensive for path and polygon objects, as
+  // the whole points/d-string has to be processed)
+  var getUntransformedBBox = function (node) {
+    if (getAttribute(node, "display") === "none") {
+      return [0, 0, 0, 0];
+    }
+
+    var i, minX, minY, maxX, maxY, viewBox, vb, boundingBox;
+    var pf = parseFloat;
+
+    if (nodeIs(node, "polygon,polyline")) {
+      var points = parsePointsString(node.getAttribute("points"));
+      minX = Number.POSITIVE_INFINITY;
+      minY = Number.POSITIVE_INFINITY;
+      maxX = Number.NEGATIVE_INFINITY;
+      maxY = Number.NEGATIVE_INFINITY;
+      for (i = 0; i < points.length; i++) {
+        var point = points[i];
+        minX = Math.min(minX, point[0]);
+        maxX = Math.max(maxX, point[0]);
+        minY = Math.min(minY, point[1]);
+        maxY = Math.max(maxY, point[1]);
+      }
+      boundingBox = [
+        minX,
+        minY,
+        maxX - minX,
+        maxY - minY
+      ];
+    } else if (nodeIs(node, "path")) {
+      var list = getPathSegList(node);
+      minX = Number.POSITIVE_INFINITY;
+      minY = Number.POSITIVE_INFINITY;
+      maxX = Number.NEGATIVE_INFINITY;
+      maxY = Number.NEGATIVE_INFINITY;
+      var x = 0, y = 0;
+      var prevX, prevY, newX, newY;
+      var p2, p3, to;
+      for (i = 0; i < list.numberOfItems; i++) {
+        var seg = list.getItem(i);
+        var cmd = seg.pathSegTypeAsLetter;
+        switch (cmd) {
+          case "H":
+            newX = seg.x;
+            newY = y;
+            break;
+          case "h":
+            newX = seg.x + x;
+            newY = y;
+            break;
+          case "V":
+            newX = x;
+            newY = seg.y;
+            break;
+          case "v":
+            newX = x;
+            newY = seg.y + y;
+            break;
+          case "C":
+            p2 = [seg.x1, seg.y1];
+            p3 = [seg.x2, seg.y2];
+            to = [seg.x, seg.y];
+            break;
+          case "c":
+            p2 = [seg.x1 + x, seg.y1 + y];
+            p3 = [seg.x2 + x, seg.y2 + y];
+            to = [seg.x + x, seg.y + y];
+            break;
+          case "S":
+            p2 = getControlPointFromPrevious(i, [x, y], list, prevX, prevY);
+            p3 = [seg.x2, seg.y2];
+            to = [seg.x, seg.y];
+            break;
+          case "s":
+            p2 = getControlPointFromPrevious(i, [x, y], list, prevX, prevY);
+            p3 = [seg.x2 + x, seg.y2 + y];
+            to = [seg.x + x, seg.y + y];
+            break;
+          case "Q":
+            pf = [seg.x1, seg.y1];
+            p2 = toCubic([x, y], pf);
+            p3 = toCubic([seg.x, seg.y], pf);
+            to = [seg.x, seg.y];
+            break;
+          case "q":
+            pf = [seg.x1 + x, seg.y1 + y];
+            p2 = toCubic([x, y], pf);
+            p3 = toCubic([x + seg.x, y + seg.y], pf);
+            to = [seg.x + x, seg.y + y];
+            break;
+          case "T":
+            p2 = getControlPointFromPrevious(i, [x, y], list, prevX, prevY);
+            p2 = toCubic([x, y], pf);
+            p3 = toCubic([seg.x, seg.y], pf);
+            to = [seg.x, seg.y];
+            break;
+          case "t":
+            pf = getControlPointFromPrevious(i, [x, y], list, prevX, prevY);
+            p2 = toCubic([x, y], pf);
+            p3 = toCubic([x + seg.x, y + seg.y], pf);
+            to = [seg.x + x, seg.y + y];
+            break;
+          // TODO: A,a
+        }
+        if ("sScCqQtT".indexOf(cmd) >= 0) {
+          prevX = x;
+          prevY = y;
+        }
+        if ("MLCSQT".indexOf(cmd) >= 0) {
+          x = seg.x;
+          y = seg.y;
+        } else if ("mlcsqt".indexOf(cmd) >= 0) {
+          x = seg.x + x;
+          y = seg.y + y;
+        } else if ("zZ".indexOf(cmd) < 0) {
+          x = newX;
+          y = newY;
+        }
+        if ("CSQTcsqt".indexOf(cmd) >= 0) {
+          minX = Math.min(minX, x, p2[0], p3[0], to[0]);
+          maxX = Math.max(maxX, x, p2[0], p3[0], to[0]);
+          minY = Math.min(minY, y, p2[1], p3[1], to[1]);
+          maxY = Math.max(maxY, y, p2[1], p3[1], to[1]);
+        } else {
+          minX = Math.min(minX, x);
+          maxX = Math.max(maxX, x);
+          minY = Math.min(minY, y);
+          maxY = Math.max(maxY, y);
+        }
+      }
+      boundingBox = [
+        minX,
+        minY,
+        maxX - minX,
+        maxY - minY
+      ];
+    } else if (nodeIs(node, "svg")) {
+      viewBox = node.getAttribute("viewBox");
+      if (viewBox) {
+        vb = parseFloats(viewBox);
+      }
+      return [
+        pf(node.getAttribute("x")) || (vb && vb[0]) || 0,
+        pf(node.getAttribute("y")) || (vb && vb[1]) || 0,
+        pf(node.getAttribute("width")) || (vb && vb[2]) || 0,
+        pf(node.getAttribute("height")) || (vb && vb[3]) || 0
+      ];
+    } else if (nodeIs(node, "g,clippath")) {
+      boundingBox = [0, 0, 0, 0];
+      forEachChild(node, function (i, node) {
+        var nodeBox = getUntransformedBBox(node);
+        boundingBox = [
+            Math.min(boundingBox[0], nodeBox[0]),
+            Math.min(boundingBox[1], nodeBox[1]),
+            Math.max(boundingBox[0] + boundingBox[2], nodeBox[0] + nodeBox[2]) - Math.min(boundingBox[0], nodeBox[0]),
+            Math.max(boundingBox[1] + boundingBox[3], nodeBox[1] + nodeBox[3]) - Math.min(boundingBox[1], nodeBox[1])
+        ];
+      });
+    } else if (nodeIs(node, "marker")) {
+      viewBox = node.getAttribute("viewBox");
+      if (viewBox) {
+        vb = parseFloats(viewBox);
+      }
+      return [
+        (vb && vb[0]) || 0,
+        (vb && vb[1]) || 0,
+        (vb && vb[2]) || pf(node.getAttribute("marker-width")) || 0,
+        (vb && vb[3]) || pf(node.getAttribute("marker-height")) || 0
+      ];
+    } else if (nodeIs(node, "pattern")) {
+      return [
+          pf(node.getAttribute("x")) || 0,
+          pf(node.getAttribute("y")) || 0,
+          pf(node.getAttribute("width")) || 0,
+          pf(node.getAttribute("height")) || 0
+      ]
+    } else {
+      // TODO: check if there are other possible coordinate attributes
+      var x1 = pf(node.getAttribute("x1")) || pf(node.getAttribute("x")) || pf((node.getAttribute("cx")) - pf(node.getAttribute("r"))) || 0;
+      var x2 = pf(node.getAttribute("x2")) || (x1 + pf(node.getAttribute("width"))) || (pf(node.getAttribute("cx")) + pf(node.getAttribute("r"))) || 0;
+      var y1 = pf(node.getAttribute("y1")) || pf(node.getAttribute("y")) || (pf(node.getAttribute("cy")) - pf(node.getAttribute("r"))) || 0;
+      var y2 = pf(node.getAttribute("y2")) || (y1 + pf(node.getAttribute("height"))) || (pf(node.getAttribute("cy")) + pf(node.getAttribute("r"))) || 0;
+      boundingBox = [
+        Math.min(x1, x2),
+        Math.min(y1, y2),
+        Math.max(x1, x2) - Math.min(x1, x2),
+        Math.max(y1, y2) - Math.min(y1, y2)
+      ];
+    }
+
+    if (!nodeIs(node, "marker,svg,g")) {
+      // add line-width
+      var lineWidth = getAttribute(node, "stroke-width") || 1;
+      var miterLimit = getAttribute(node, "stroke-miterlimit");
+      // miterLength / lineWidth = 1 / sin(phi / 2)
+      miterLimit && (lineWidth *= 0.5 / (Math.sin(Math.PI / 12)));
+      return [
+          boundingBox[0] - lineWidth,
+          boundingBox[1] - lineWidth,
+          boundingBox[2] + 2 * lineWidth,
+          boundingBox[3] + 2 * lineWidth
+      ];
+    }
+
+    return boundingBox;
+  };
+
+  // transforms a bounding box and returns a new rect that contains it
+  var transformBBox = function (box, matrix) {
+    var bl = multVecMatrix([box[0], box[1]], matrix);
+    var br = multVecMatrix([box[0] + box[2], box[1]], matrix);
+    var tl = multVecMatrix([box[0], box[1] + box[3]], matrix);
+    var tr = multVecMatrix([box[0] + box[2], box[1] + box[3]], matrix);
+
+    var bottom = Math.min(bl[1], br[1], tl[1], tr[1]);
+    var left = Math.min(bl[0], br[0], tl[0], tr[0]);
+    var top = Math.max(bl[1], br[1], tl[1], tr[1]);
+    var right = Math.max(bl[0], br[0], tl[0], tr[0]);
+
+    return [
+      left,
+      bottom,
+      right - left,
+      top - bottom
+    ]
+  };
+
+  // draws a polygon
+  var polygon = function (node, refsHandler, attributeState, closed) {
+    if (!node.hasAttribute("points") || node.getAttribute("points") === "") {
+      return;
+    }
+
+    var points = parsePointsString(node.getAttribute("points"));
+    var lines = [{op: "m", c: points[0]}];
+    var i, angle;
+    for (i = 1; i < points.length; i++) {
+      lines.push({op: "l", c: points[i]});
+    }
+
+    if (closed) {
+      lines.push({op: "h"});
+    }
+
+    _pdf.path(lines);
+
+    var markerEnd = node.getAttribute("marker-end"),
+        markerStart = node.getAttribute("marker-start"),
+        markerMid = node.getAttribute("marker-mid");
+
+    if (markerStart || markerMid || markerEnd) {
+      var length = lines.length;
+      var markers = new MarkerList();
+      if (markerStart) {
+        markerStart = iriReference.exec(markerStart)[1];
+        angle = addVectors(getDirectionVector(lines[0].c, lines[1].c), getDirectionVector(lines[length - 2].c, lines[0].c));
+        markers.addMarker(new Marker(markerStart, lines[0].c, Math.atan2(angle[1], angle[0])));
+      }
+
+      if (markerMid) {
+        markerMid = iriReference.exec(markerMid)[1];
+        var prevAngle = getDirectionVector(lines[0].c, lines[1].c), curAngle;
+        for (i = 1; i < lines.length - 2; i++) {
+          curAngle = getDirectionVector(lines[i].c, lines[i + 1].c);
+          angle = addVectors(prevAngle, curAngle);
+          markers.addMarker(new Marker(markerMid, lines[i].c, Math.atan2(angle[1], angle[0])));
+          prevAngle = curAngle;
+        }
+
+        curAngle = getDirectionVector(lines[length - 2].c, lines[0].c);
+        angle = addVectors(prevAngle, curAngle);
+        markers.addMarker(new Marker(markerMid, lines[length - 2].c, Math.atan2(angle[1], angle[0])));
+      }
+
+      if (markerEnd) {
+        markerEnd = iriReference.exec(markerEnd)[1];
+        angle = addVectors(getDirectionVector(lines[0].c, lines[1].c), getDirectionVector(lines[length - 2].c, lines[0].c));
+        markers.addMarker(new Marker(markerEnd, lines[0].c, Math.atan2(angle[1], angle[0])));
+      }
+
+      markers.draw(_pdf.unitMatrix, refsHandler, attributeState);
+    }
+  };
+
+  // draws an image
+  var image = function (node) {
+    var width = parseFloat(node.getAttribute("width")),
+        height = parseFloat(node.getAttribute("height")),
+        x = parseFloat(node.getAttribute("x") || 0),
+        y = parseFloat(node.getAttribute("y") || 0);
+
+
+    var imageUrl = node.getAttribute("xlink:href") || node.getAttribute("href");
+
+    var dataUrl = imageUrl.match(dataUrlRegex);
+    if (dataUrl && dataUrl[2] === "image/svg+xml") {
+      var svgText = dataUrl[5];
+      if (dataUrl[4] === "base64") {
+        svgText = atob(svgText);
+      } else {
+        svgText = decodeURIComponent(svgText);
+      }
+
+      var parser = new DOMParser();
+      var svgElement = parser.parseFromString(svgText, "image/svg+xml").firstElementChild;
+
+      // unless preserveAspectRatio starts with "defer", the preserveAspectRatio attribute of the svg is ignored
+      var preserveAspectRatio = node.getAttribute("preserveAspectRatio");
+      if (!preserveAspectRatio
+          || preserveAspectRatio.indexOf("defer") < 0
+          || !svgElement.getAttribute("preserveAspectRatio")) {
+        svgElement.setAttribute("preserveAspectRatio", preserveAspectRatio);
+      }
+
+      svgElement.setAttribute("x", String(x));
+      svgElement.setAttribute("y", String(y));
+      svgElement.setAttribute("width", String(width));
+      svgElement.setAttribute("height", String(height));
+
+      renderNode(svgElement, _pdf.unitMatrix, {}, false, false, AttributeState.default());
+      return;
+    }
+
+    try {
+      _pdf.addImage(
+          imageUrl,
+          "", // will be ignored anyways if imageUrl is a data url
+          x,
+          y,
+          width,
+          height
+      );
+    } catch (e) {
+      (typeof console === "object"
+          && console.warn
+          && console.warn('svg2pdfjs: Images with external resource link are not supported! ("' + imageUrl + '")'));
+    }
+  };
+
+  // draws a path
+  var path = function (node, tfMatrix, refsHandler, withinClipPath, attributeState) {
+    var list = getPathSegList(node);
+    var markerEnd = node.getAttribute("marker-end"),
+        markerStart = node.getAttribute("marker-start"),
+        markerMid = node.getAttribute("marker-mid");
+
+    markerEnd && (markerEnd = iriReference.exec(markerEnd)[1]);
+    markerStart && (markerStart = iriReference.exec(markerStart)[1]);
+    markerMid && (markerMid = iriReference.exec(markerMid)[1]);
+
+    var getLinesFromPath = function () {
+      var x = 0, y = 0;
+      var x0 = x, y0 = y;
+      var prevX, prevY, newX, newY;
+      var to, p, p2, p3;
+      var lines = [];
+      var markers = new MarkerList();
+      var op;
+      var prevAngle = [0, 0], curAngle;
+
+      for (var i = 0; i < list.numberOfItems; i++) {
+        var seg = list.getItem(i);
+        var cmd = seg.pathSegTypeAsLetter;
+        switch (cmd) {
+          case "M":
+            x0 = x;
+            y0 = y;
+            to = [seg.x, seg.y];
+            op = "m";
+            break;
+          case "m":
+            x0 = x;
+            y0 = y;
+            to = [seg.x + x, seg.y + y];
+            op = "m";
+            break;
+          case "L":
+            to = [seg.x, seg.y];
+            op = "l";
+            break;
+          case "l":
+            to = [seg.x + x, seg.y + y];
+            op = "l";
+            break;
+          case "H":
+            to = [seg.x, y];
+            op = "l";
+            newX = seg.x;
+            newY = y;
+            break;
+          case "h":
+            to = [seg.x + x, y];
+            op = "l";
+            newX = seg.x + x;
+            newY = y;
+            break;
+          case "V":
+            to = [x, seg.y];
+            op = "l";
+            newX = x;
+            newY = seg.y;
+            break;
+          case "v":
+            to = [x, seg.y + y];
+            op = "l";
+            newX = x;
+            newY = seg.y + y;
+            break;
+          case "C":
+            p2 = [seg.x1, seg.y1];
+            p3 = [seg.x2, seg.y2];
+            to = [seg.x, seg.y];
+            break;
+          case "c":
+            p2 = [seg.x1 + x, seg.y1 + y];
+            p3 = [seg.x2 + x, seg.y2 + y];
+            to = [seg.x + x, seg.y + y];
+            break;
+          case "S":
+            p2 = getControlPointFromPrevious(i, [x, y], list, prevX, prevY);
+            p3 = [seg.x2, seg.y2];
+            to = [seg.x, seg.y];
+            break;
+          case "s":
+            p2 = getControlPointFromPrevious(i, [x, y], list, prevX, prevY);
+            p3 = [seg.x2 + x, seg.y2 + y];
+            to = [seg.x + x, seg.y + y];
+            break;
+          case "Q":
+            p = [seg.x1, seg.y1];
+            p2 = toCubic([x, y], p);
+            p3 = toCubic([seg.x, seg.y], p);
+            to = [seg.x, seg.y];
+            break;
+          case "q":
+            p = [seg.x1 + x, seg.y1 + y];
+            p2 = toCubic([x, y], p);
+            p3 = toCubic([x + seg.x, y + seg.y], p);
+            to = [seg.x + x, seg.y + y];
+            break;
+          case "T":
+            p = getControlPointFromPrevious(i, [x, y], list, prevX, prevY);
+            p2 = toCubic([x, y], p);
+            p3 = toCubic([seg.x, seg.y], p);
+            to = [seg.x, seg.y];
+            break;
+          case "t":
+            p = getControlPointFromPrevious(i, [x, y], list, prevX, prevY);
+            p2 = toCubic([x, y], p);
+            p3 = toCubic([x + seg.x, y + seg.y], p);
+            to = [seg.x + x, seg.y + y];
+            break;
+          // TODO: A,a
+          case "Z":
+          case "z":
+            x = x0;
+            y = y0;
+            lines.push({op: "h"});
+            break;
+        }
+
+        var hasStartMarker = markerStart
+            && (i === 1
+            || ("mM".indexOf(cmd) < 0 && "mM".indexOf(list.getItem(i - 1).pathSegTypeAsLetter) >= 0));
+        var hasEndMarker = markerEnd
+            && (i === list.numberOfItems - 1
+            || ("mM".indexOf(cmd) < 0 && "mM".indexOf(list.getItem(i + 1).pathSegTypeAsLetter) >= 0));
+        var hasMidMarker = markerMid
+            && i > 0
+            && !(i === 1 && "mM".indexOf(list.getItem(i - 1).pathSegTypeAsLetter) >= 0);
+
+        if ("sScCqQtT".indexOf(cmd) >= 0) {
+          hasStartMarker && markers.addMarker(new Marker(markerStart, [x, y], getAngle([x, y], p2)));
+          hasEndMarker && markers.addMarker(new Marker(markerEnd, to, getAngle(p3, to)));
+          if (hasMidMarker) {
+            curAngle = getDirectionVector([x, y], p2);
+            curAngle = "mM".indexOf(list.getItem(i - 1).pathSegTypeAsLetter) >= 0 ?
+                curAngle : normalize(addVectors(prevAngle, curAngle));
+            markers.addMarker(new Marker(markerMid, [x, y], Math.atan2(curAngle[1], curAngle[0])));
+          }
+
+          prevAngle = getDirectionVector(p3, to);
+
+          prevX = x;
+          prevY = y;
+
+          if (withinClipPath) {
+            p2 = multVecMatrix(p2, tfMatrix);
+            p3 = multVecMatrix(p3, tfMatrix);
+            to = multVecMatrix(to, tfMatrix);
+          }
+
+          lines.push({
+            op: "c", c: [
+              p2[0], p2[1],
+              p3[0], p3[1],
+              to[0], to[1]
+            ]
+          });
+        } else if ("lLhHvVmM".indexOf(cmd) >= 0) {
+          curAngle = getDirectionVector([x, y], to);
+          hasStartMarker && markers.addMarker(new Marker(markerStart, [x, y], Math.atan2(curAngle[1], curAngle[0])));
+          hasEndMarker && markers.addMarker(new Marker(markerEnd, to, Math.atan2(curAngle[1], curAngle[0])));
+          if (hasMidMarker) {
+            var angle = "mM".indexOf(cmd) >= 0 ?
+                prevAngle : "mM".indexOf(list.getItem(i - 1).pathSegTypeAsLetter) >= 0 ?
+                curAngle : normalize(addVectors(prevAngle, curAngle));
+            markers.addMarker(new Marker(markerMid, [x, y], Math.atan2(angle[1], angle[0])));
+          }
+          prevAngle = curAngle;
+
+          if (withinClipPath) {
+            to = multVecMatrix(to, tfMatrix);
+          }
+
+          lines.push({op: op, c: to});
+        }
+
+        if ("MLCSQT".indexOf(cmd) >= 0) {
+          x = seg.x;
+          y = seg.y;
+        } else if ("mlcsqt".indexOf(cmd) >= 0) {
+          x = seg.x + x;
+          y = seg.y + y;
+        } else if ("zZ".indexOf(cmd) < 0) {
+          x = newX;
+          y = newY;
+        }
+      }
+
+      return {lines: lines, markers: markers};
+    };
+    var lines = getLinesFromPath();
+
+    if (lines.lines.length > 0) {
+      _pdf.path(lines.lines);
+    }
+
+    if (markerEnd || markerStart || markerMid) {
+      lines.markers.draw(_pdf.unitMatrix, refsHandler, attributeState);
+    }
+  };
+
+  // draws the element referenced by a use node, makes use of pdf's XObjects/FormObjects so nodes are only written once
+  // to the pdf document. This highly reduces the file size and computation time.
+  var use = function (node, tfMatrix, refsHandler) {
+    var url = (node.getAttribute("href") || node.getAttribute("xlink:href"));
+    // just in case someone has the idea to use empty use-tags, wtf???
+    if (!url)
+      return;
+
+    // get the size of the referenced form object (to apply the correct scaling)
+    var id = url.substring(1);
+    refsHandler.getRendered(id);
+    var formObject = _pdf.getFormObject(id);
+
+    // scale and position it right
+    var x = node.getAttribute("x") || 0;
+    var y = node.getAttribute("y") || 0;
+    var width = node.getAttribute("width") || formObject.width;
+    var height = node.getAttribute("height") || formObject.height;
+    var t = new _pdf.Matrix(width / formObject.width || 0, 0, 0, height / formObject.height || 0, x, y);
+    t = _pdf.matrixMult(t, tfMatrix);
+    _pdf.doFormObject(id, t);
+  };
+
+  // draws a line
+  var line = function (node, refsHandler, attributeState) {
+    var p1 = [parseFloat(node.getAttribute('x1') || 0), parseFloat(node.getAttribute('y1') || 0)];
+    var p2 = [parseFloat(node.getAttribute('x2') || 0), parseFloat(node.getAttribute('y2') || 0)];
+
+    if (attributeState.stroke !== null){
+      _pdf.line(p1[0], p1[1], p2[0], p2[1]);
+    }
+
+    var markerStart = node.getAttribute("marker-start"),
+        markerEnd = node.getAttribute("marker-end");
+
+    if (markerStart || markerEnd) {
+      var markers = new MarkerList();
+      var angle = getAngle(p1, p2);
+      if (markerStart) {
+        markers.addMarker(new Marker(iriReference.exec(markerStart)[1], p1, angle));
+      }
+      if (markerEnd) {
+        markers.addMarker(new Marker(iriReference.exec(markerEnd)[1], p2, angle));
+      }
+      markers.draw(_pdf.unitMatrix, refsHandler, attributeState);
+    }
+  };
+
+  // draws a rect
+  var rect = function (node) {
+    _pdf.roundedRect(
+        parseFloat(node.getAttribute('x')) || 0,
+        parseFloat(node.getAttribute('y')) || 0,
+        parseFloat(node.getAttribute('width')),
+        parseFloat(node.getAttribute('height')),
+        parseFloat(node.getAttribute('rx')) || 0,
+        parseFloat(node.getAttribute('ry')) || 0
+    );
+  };
+
+  // draws an ellipse
+  var ellipse = function (node) {
+    _pdf.ellipse(
+        parseFloat(node.getAttribute('cx')) || 0,
+        parseFloat(node.getAttribute('cy')) || 0,
+        parseFloat(node.getAttribute('rx')),
+        parseFloat(node.getAttribute('ry'))
+    );
+  };
+
+  // draws a circle
+  var circle = function (node) {
+    var radius = parseFloat(node.getAttribute('r')) || 0;
+    _pdf.ellipse(
+        parseFloat(node.getAttribute('cx')) || 0,
+        parseFloat(node.getAttribute('cy')) || 0,
+        radius,
+        radius
+    );
+  };
+
+  // applies text transformations to a text node
+  var transformText = function (node, text) {
+    var textTransform = getAttribute(node, "text-transform");
+    switch (textTransform) {
+      case "uppercase": return text.toUpperCase();
+      case "lowercase": return text.toLowerCase();
+      default: return text;
+      // TODO: capitalize, full-width
+    }
+  };
+
+  /**
+   * Canvas text measuring is a lot faster than svg measuring. However, it is inaccurate for some fonts. So test each
+   * font once and decide if canvas is accurate enough.
+   * @param {string} text
+   * @param {string} fontFamily
+   * @returns {function(string, string, string, string, string)}
+   */
+  var getMeasureFunction = (function getMeasureFunction() {
+    /**
+     * @param {string} text
+     * @param {string} fontFamily
+     * @param {string} fontSize
+     * @param {string} fontStyle
+     * @param {string} fontWeight
+     */
+    function canvasTextMeasure(text, fontFamily, fontSize, fontStyle, fontWeight) {
+      var canvas = document.createElement("canvas");
+      var context = canvas.getContext("2d");
+
+      context.font = [fontStyle, fontWeight, fontSize, fontFamily].join(" ");
+      return context.measureText(text).width;
+    }
+
+    /**
+     * @param {string} text
+     * @param {string} fontFamily
+     * @param {string} fontSize
+     * @param {string} fontStyle
+     * @param {string} fontWeight
+     */
+    function svgTextMeasure(text, fontFamily, fontSize, fontStyle, fontWeight) {
+      var textNode = document.createElementNS(svgNamespaceURI, "text");
+      textNode.setAttribute("font-family", fontFamily);
+      textNode.setAttribute("font-size", fontSize);
+      textNode.setAttribute("font-style", fontStyle);
+      textNode.setAttribute("font-weight", fontWeight);
+      textNode.setAttributeNS("http://www.w3.org/XML/1998/namespace", "xml:space", "preserve");
+      textNode.appendChild(document.createTextNode(text));
+
+      var svg = document.createElementNS(svgNamespaceURI, "svg");
+      svg.appendChild(textNode);
+      svg.setAttribute("visibility", "hidden");
+      document.body.appendChild(svg);
+
+      var width = textNode.getBBox().width;
+
+      document.body.removeChild(svg);
+
+      return width;
+    }
+
+    var testString = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789!\"$%&/()=?'\\+*-_.:,;^}][{#~|<>";
+    var epsilon = 0.1;
+    var measureMethods = {};
+
+    return function getMeasureFunction(fontFamily) {
+      var method = measureMethods[fontFamily];
+      if (!method) {
+        var fontSize = "16px";
+        var fontStyle = "normal";
+        var fontWeight = "normal";
+        var canvasWidth = canvasTextMeasure(testString, fontFamily, fontSize, fontStyle, fontWeight);
+        var svgWidth = svgTextMeasure(testString, fontFamily, fontSize, fontStyle, fontWeight);
+
+        method = Math.abs(canvasWidth - svgWidth) < epsilon ? canvasTextMeasure : svgTextMeasure;
+
+        measureMethods[fontFamily] = method;
+      }
+
+      return method;
+    }
+  })();
+
+  /**
+   * @param {string} text
+   * @param {AttributeState} attributeState
+   * @returns {number}
+   */
+  function measureTextWidth(text, attributeState) {
+    if (text.length === 0) {
+      return 0;
+    }
+
+    var fontFamily = attributeState.fontFamily;
+    var measure = getMeasureFunction(fontFamily);
+
+    return measure(text, attributeState.fontFamily, attributeState.fontSize + "px", attributeState.fontStyle, attributeState.fontWeight);
+  }
+
+  /**
+   * @param {string} text
+   * @param {AttributeState} attributeState
+   * @returns {number}
+   */
+  function getTextOffset(text, attributeState) {
+    var textAnchor = attributeState.textAnchor;
+    if (textAnchor === "start") {
+      return 0;
+    }
+
+    var width = measureTextWidth(text, attributeState);
+
+    var xOffset = 0;
+    switch (textAnchor) {
+      case "end":
+        xOffset = width;
+        break;
+      case "middle":
+        xOffset = width / 2;
+        break;
+    }
+
+    return xOffset;
+  }
+
+  /**
+   * @param {string} textAnchor
+   * @param {number} originX
+   * @param {number} originY
+   * @constructor
+   */
+  function TextChunk(textAnchor, originX, originY) {
+    this.texts = [];
+    this.textNodes = [];
+    this.textAnchor = textAnchor;
+    this.originX = originX;
+    this.originY = originY;
+  }
+
+  /**
+   * @param {SVGElement} tSpan
+   * @param {string} text
+   */
+  TextChunk.prototype.add = function(tSpan, text) {
+    this.texts.push(text);
+    this.textNodes.push(tSpan);
+  };
+  /**
+   * Outputs the chunk to pdf.
+   * @param {jsPDF.Matrix} transform
+   * @param {AttributeState} attributeState
+   * @returns {[number, number]} The last current text position.
+   */
+  TextChunk.prototype.put = function (transform, attributeState) {
+    var i, textNode;
+
+    var xs = [], ys = [], attributeStates = [];
+    var currentTextX = this.originX, currentTextY = this.originY;
+    var minX = currentTextX, maxX = currentTextX;
+    for (i = 0; i < this.textNodes.length; i++) {
+      textNode = this.textNodes[i];
+
+      var x = currentTextX;
+      var y = currentTextY;
+
+      if (textNode.nodeName === "#text") {
+        textNodeAttributeState = attributeState
+      } else {
+        var textNodeAttributeState = attributeState.clone();
+        var tSpanColor = getAttribute(textNode, "fill");
+        setTextProperties(textNode, tSpanColor && new RGBColor(tSpanColor), textNodeAttributeState);
+
+        var tSpanDx = textNode.getAttribute("dx");
+        if (tSpanDx !== null) {
+          x += toPixels(tSpanDx, textNodeAttributeState.fontSize);
+        }
+
+        var tSpanDy = textNode.getAttribute("dy");
+        if (tSpanDy !== null) {
+          y += toPixels(tSpanDy, textNodeAttributeState.fontSize);
+        }
+      }
+
+      attributeStates[i] = textNodeAttributeState;
+
+      xs[i] = x;
+      ys[i] = y;
+
+      currentTextX = x + measureTextWidth(this.texts[i], textNodeAttributeState);
+
+      currentTextY = y;
+
+      minX = Math.min(minX, x);
+      maxX = Math.max(maxX, currentTextX);
+    }
+
+    var textOffset;
+    switch (this.textAnchor) {
+      case "start": textOffset = 0; break;
+      case "middle": textOffset = (maxX - minX) / 2; break;
+      case "end": textOffset = maxX - minX; break;
+    }
+
+    for (i = 0; i < this.textNodes.length; i++) {
+      textNode = this.textNodes[i];
+
+      if (textNode.nodeName !== "#text") {
+        var tSpanVisibility = getAttribute(textNode, "visibility") || attributeState.visibility;
+        if (tSpanVisibility === "hidden") {
+          continue;
+        }
+      }
+
+      _pdf.saveGraphicsState();
+      putTextProperties(attributeStates[i], attributeState);
+
+      _pdf.text(xs[i] - textOffset, ys[i], this.texts[i], void 0, transform);
+
+      _pdf.restoreGraphicsState();
+    }
+
+    return [currentTextX, currentTextY];
+  };
+
+  /**
+   * Convert em, px and bare number attributes to pixel values
+   * @param {string} value
+   * @param {number} pdfFontSize
+   */
+  function toPixels(value, pdfFontSize) {
+    var match;
+
+    // em
+    match = value && value.toString().match(/^([\-0-9.]+)em$/);
+    if (match) {
+      return parseFloat(match[1]) * pdfFontSize;
+    }
+
+    // pixels
+    match = value && value.toString().match(/^([\-0-9.]+)(px|)$/);
+    if (match) {
+      return parseFloat(match[1]);
+    }
+    return 0;
+  }
+
+
+  function transformXmlSpace(trimmedText, attributeState) {
+    trimmedText = removeNewlines(trimmedText);
+    trimmedText = replaceTabsBySpace(trimmedText);
+
+    if (attributeState.xmlSpace === "default") {
+      trimmedText = trimmedText.trim();
+      trimmedText = consolidateSpaces(trimmedText);
+    }
+
+    return trimmedText;
+  }
+
+  /**
+   * Draws a text element and its tspan children.
+   * @param {SVGElement} node
+   * @param {jsPDF.Matrix} tfMatrix
+   * @param {boolean} hasFillColor
+   * @param {RGBColor} fillRGB
+   * @param {AttributeState} attributeState
+   */
+  var text = function (node, tfMatrix, hasFillColor, fillRGB, attributeState) {
+    _pdf.saveGraphicsState();
+
+    var dx, dy, xOffset = 0;
+
+    var pdfFontSize = _pdf.getFontSize();
+    var textX = toPixels(node.getAttribute('x'), pdfFontSize);
+    var textY = toPixels(node.getAttribute('y'), pdfFontSize);
+
+    dx = toPixels(node.getAttribute("dx"), pdfFontSize);
+    dy = toPixels(node.getAttribute("dy"), pdfFontSize);
+
+    var visibility = attributeState.visibility;
+    // when there are no tspans draw the text directly
+    var tSpanCount = node.childElementCount;
+    if (tSpanCount === 0) {
+      var trimmedText = transformXmlSpace(node.textContent, attributeState);
+      var transformedText = transformText(node, trimmedText);
+      xOffset = getTextOffset(transformedText, attributeState);
+
+      if (visibility === "visible") {
+        _pdf.text(
+            textX + dx - xOffset,
+            textY + dy,
+            transformedText,
+            void 0,
+            tfMatrix
+        );
+      }
+    } else {
+      // otherwise loop over tspans and position each relative to the previous one
+      var currentTextSegment = new TextChunk(attributeState.textAnchor, textX + dx, textY + dy);
+
+      for (var i = 0; i < node.childNodes.length; i++) {
+        var textNode = node.childNodes[i];
+        if (!textNode.textContent) {
+          continue;
+        }
+
+        var xmlSpace = attributeState.xmlSpace;
+
+        if (textNode.nodeName === "#text") {
+
+        } else if (nodeIs(textNode, "tspan")) {
+          var tSpan = textNode;
+
+          var lastPositions;
+
+          var tSpanAbsX = tSpan.getAttribute("x");
+          if (tSpanAbsX !== null) {
+            var x = toPixels(tSpanAbsX, pdfFontSize);
+
+            lastPositions = currentTextSegment.put(tfMatrix, attributeState);
+            currentTextSegment = new TextChunk(tSpan.getAttribute("text-anchor") || attributeState.textAnchor, x, lastPositions[1]);
+          }
+
+          var tSpanAbsY = tSpan.getAttribute("y");
+          if (tSpanAbsY !== null) {
+            var y = toPixels(tSpanAbsY, pdfFontSize);
+
+            lastPositions = currentTextSegment.put(tfMatrix, attributeState);
+            currentTextSegment = new TextChunk(tSpan.getAttribute("text-anchor") || attributeState.textAnchor, lastPositions[0], y);
+          }
+
+          var tSpanXmlSpace = tSpan.getAttribute("xml:space");
+          if (tSpanXmlSpace) {
+            xmlSpace = tSpanXmlSpace;
+          }
+        }
+
+        trimmedText = textNode.textContent;
+        trimmedText = removeNewlines(trimmedText);
+        trimmedText = replaceTabsBySpace(trimmedText);
+
+        if (xmlSpace === "default") {
+          if (i === 0) {
+            trimmedText = trimLeft(trimmedText);
+          }
+          if (i === tSpanCount - 1) {
+            trimmedText = trimRight(trimmedText);
+          }
+
+          trimmedText = consolidateSpaces(trimmedText);
+        }
+
+        transformedText = transformText(node, trimmedText);
+        currentTextSegment.add(textNode, transformedText);
+      }
+
+      currentTextSegment.put(tfMatrix, attributeState);
+    }
+
+    _pdf.restoreGraphicsState();
+  };
+
+  // renders all children of a node
+  var renderChildren = function (node, tfMatrix, refsHandler, withinDefs, withinClipPath, attributeState) {
+    forEachChild(node, function (i, node) {
+      renderNode(node, tfMatrix, refsHandler, withinDefs, withinClipPath, attributeState);
+    });
+  };
+
+  // adds a gradient to defs and the pdf document for later use, type is either "axial" or "radial"
+  // opacity is only supported rudimentary by averaging over all stops
+  // transforms are applied on use
+  var putGradient = function (node, type, coords) {
+    var colors = [];
+    var opacitySum = 0;
+    var hasOpacity = false;
+    var gState;
+    forEachChild(node, function (i, element) {
+      // since opacity gradients are hard to realize, average the opacity over the control points
+      if (element.tagName.toLowerCase() === "stop") {
+        var color = new RGBColor(getAttribute(element, "stop-color"));
+        colors.push({
+          offset: parseFloat(element.getAttribute("offset")),
+          color: [color.r, color.g, color.b]
+        });
+        var opacity = getAttribute(element, "stop-opacity");
+        if (opacity && opacity != 1) {
+          opacitySum += parseFloat(opacity);
+          hasOpacity = true;
+        }
+      }
+    });
+
+    if (hasOpacity) {
+      gState = new _pdf.GState({opacity: opacitySum / colors.length});
+    }
+
+    var pattern = new _pdf.ShadingPattern(type, coords, colors, gState);
+    var id = node.getAttribute("id");
+    _pdf.addShadingPattern(id, pattern);
+  };
+
+  var pattern = function (node, refsHandler, attributeState) {
+    var id = node.getAttribute("id");
+
+    // the transformations directly at the node are written to the pattern transformation matrix
+    var bBox = getUntransformedBBox(node);
+    var pattern = new _pdf.TilingPattern([bBox[0], bBox[1], bBox[0] + bBox[2], bBox[1] + bBox[3]], bBox[2], bBox[3],
+        null, _pdf.unitMatrix /* this parameter is ignored !*/);
+
+    _pdf.beginTilingPattern(pattern);
+    // continue without transformation
+    renderChildren(node, _pdf.unitMatrix, refsHandler, false, false, attributeState);
+    _pdf.endTilingPattern(id, pattern);
+  };
+
+  var fontAliases = {
+    "sans-serif": "helvetica",
+    "verdana": "helvetica",
+    "arial": "helvetica",
+
+    "fixed": "courier",
+    "monospace": "courier",
+    "terminal": "courier",
+
+    "serif": "times",
+    "cursive": "times",
+    "fantasy": "times"
+  };
+
+  /**
+   * @param {AttributeState} attributeState
+   * @param {string[]} fontFamilies
+   * @return {string}
+   */
+  function findFirstAvailableFontFamily(attributeState, fontFamilies) {
+    var fontType = "";
+    if (attributeState.fontWeight === "bold") {
+      fontType = "bold";
+    }
+    if (attributeState.fontStyle === "italic") {
+      fontType += "italic";
+    }
+    if (fontType === "") {
+      fontType = "normal";
+    }
+
+    var availableFonts = _pdf.getFontList();
+    var firstAvailable = "";
+    var fontIsAvailable = fontFamilies.some(function (font) {
+      var availableStyles = availableFonts[font];
+      if (availableStyles && availableStyles.indexOf(fontType) >= 0) {
+        firstAvailable = font;
+        return true;
+      }
+
+      font = font.toLowerCase();
+      if (fontAliases.hasOwnProperty(font)) {
+        firstAvailable = font;
+        return true;
+      }
+
+      return false;
+    });
+
+    if (!fontIsAvailable) {
+      firstAvailable = "times";
+    }
+
+    return firstAvailable;
+  }
+
+  function setTextProperties(node, fillRGB, attributeState) {
+    if (fillRGB && fillRGB.ok) {
+      attributeState.fill = fillRGB;
+    }
+
+    var fontWeight = getAttribute(node, "font-weight");
+    if (fontWeight) {
+      attributeState.fontWeight = fontWeight;
+    }
+
+    var fontStyle = getAttribute(node, "font-style");
+    if (fontStyle) {
+      attributeState.fontStyle = fontStyle;
+    }
+
+    var fontFamily = getAttribute(node, "font-family");
+    if (fontFamily) {
+      var fontFamilies = FontFamily.parse(fontFamily);
+      attributeState.fontFamily = findFirstAvailableFontFamily(attributeState, fontFamilies);
+    }
+
+    var fontSize = getAttribute(node, "font-size");
+    if (fontSize) {
+      attributeState.fontSize = parseFloat(fontSize);
+    }
+
+    var textAnchor = getAttribute(node, "text-anchor");
+    if (textAnchor) {
+      attributeState.textAnchor = textAnchor;
+    }
+  }
+
+  /**
+   * @param {AttributeState} attributeState
+   * @param {AttributeState} parentAttributeState
+   */
+  function putTextProperties(attributeState, parentAttributeState) {
+    if (attributeState.fontFamily !== parentAttributeState.fontFamily) {
+      if (fontAliases.hasOwnProperty(attributeState.fontFamily)) {
+        _pdf.setFont(fontAliases[attributeState.fontFamily]);
+      } else {
+        _pdf.setFont(attributeState.fontFamily);
+      }
+    }
+
+    if (attributeState.fill !== parentAttributeState.fill && attributeState.fill.ok) {
+      var fillRGB = attributeState.fill;
+      _pdf.setTextColor(fillRGB.r, fillRGB.g, fillRGB.b);
+    }
+
+    if (attributeState.fontWeight !== parentAttributeState.fontWeight
+        || attributeState.fontStyle !== parentAttributeState.fontStyle) {
+      var fontType = "";
+      if (attributeState.fontWeight === "bold") {
+        fontType = "bold";
+      }
+      if (attributeState.fontStyle === "italic") {
+        fontType += "italic";
+      }
+
+      if (fontType === "") {
+        fontType = "normal";
+      }
+
+      _pdf.setFontType(fontType);
+    }
+
+    if (attributeState.fontSize !== parentAttributeState.fontSize) {
+      _pdf.setFontSize(attributeState.fontSize);
+    }
+  }
+
+
+  /**
+   * Renders a svg node.
+   * @param node The svg element
+   * @param contextTransform The current transformation matrix
+   * @param refsHandler The handler that will render references on demand
+   * @param withinDefs True iff we are top-level within a defs node, so the target can be switched to an pdf form object
+   * @param {boolean} withinClipPath
+   * @param {AttributeState} attributeState Keeps track of parent attributes that are inherited automatically
+   */
+  var renderNode = function (node, contextTransform, refsHandler, withinDefs, withinClipPath, attributeState) {
+    var parentAttributeState = attributeState;
+    attributeState = attributeState.clone();
+
+    if (nodeIs(node, "defs,clippath,pattern,lineargradient,radialgradient,marker")) {
+      // we will only render them on demand
+      return;
+    }
+
+    if (getAttribute(node, "display") === "none") {
+      return;
+    }
+
+    var visibility = attributeState.visibility = getAttribute(node, "visibility") || attributeState.visibility;
+    if (visibility === "hidden" && !nodeIs(node, "svg,g,marker,a,pattern,defs,text")) {
+      return;
+    }
+
+    var tfMatrix,
+        hasFillColor = false,
+        fillRGB = null,
+        fill = "inherit",
+        stroke = "inherit",
+        patternOrGradient = undefined,
+        bBox;
+
+    //
+    // Decide about the render target and set the correct transformation
+    //
+
+    // if we are within a defs node, start a new pdf form object and draw this node and all children on that instead
+    // of the top-level page
+    var targetIsFormObject = withinDefs && !nodeIs(node, "lineargradient,radialgradient,pattern,clippath");
+    if (targetIsFormObject) {
+
+      // the transformations directly at the node are written to the pdf form object transformation matrix
+      tfMatrix = computeNodeTransform(node);
+      bBox = getUntransformedBBox(node);
+
+      _pdf.beginFormObject(bBox[0], bBox[1], bBox[2], bBox[3], tfMatrix);
+
+      // continue without transformation and set withinDefs to false to prevent child nodes from starting new form objects
+      tfMatrix = _pdf.unitMatrix;
+      withinDefs = false;
+
+    } else {
+      tfMatrix = _pdf.matrixMult(computeNodeTransform(node), contextTransform);
+
+      if (!withinClipPath) {
+        _pdf.saveGraphicsState();
+      }
+    }
+
+    var hasClipPath = node.hasAttribute("clip-path") && node.getAttribute("clip-path") !== "none";
+    if (hasClipPath) {
+      var clipPathId = iriReference.exec(node.getAttribute("clip-path"));
+      var clipPathNode = refsHandler.getRendered(clipPathId[1]);
+
+      var clipPathMatrix = tfMatrix;
+      if (clipPathNode.hasAttribute("clipPathUnits")
+          && clipPathNode.getAttribute("clipPathUnits").toLowerCase() === "objectboundingbox") {
+        bBox = getUntransformedBBox(node);
+        clipPathMatrix = _pdf.matrixMult(new _pdf.Matrix(bBox[2], 0, 0, bBox[3], bBox[0], bBox[1]), clipPathMatrix);
+      }
+
+      // here, browsers show different results for a "transform" attribute on the clipPath element itself:
+      // IE/Edge considers it, Chrome and Firefox ignore it. However, the specification lists "transform" as a valid
+      // attribute for clipPath elements, although not explicitly explaining its behavior. This implementation follows
+      // IE/Edge and considers the "transform" attribute as additional transformation within the coordinate system
+      // established by the "clipPathUnits" attribute.
+      clipPathMatrix = _pdf.matrixMult(computeNodeTransform(clipPathNode), clipPathMatrix);
+
+      _pdf.saveGraphicsState();
+      _pdf.setCurrentTransformationMatrix(clipPathMatrix);
+
+      renderChildren(clipPathNode, _pdf.unitMatrix, refsHandler, false, true, attributeState);
+      _pdf.clip().discardPath();
+
+      // as we cannot use restoreGraphicsState() to reset the transform (this would reset the clipping path, as well),
+      // we must append the inverse instead
+      _pdf.setCurrentTransformationMatrix(clipPathMatrix.inversed());
+    }
+
+    //
+    // extract fill and stroke mode
+    //
+
+    // fill mode
+    if (nodeIs(node, "g,path,rect,text,ellipse,line,circle,polygon,polyline")) {
+      function setDefaultColor() {
+        fillRGB = new RGBColor("rgb(0, 0, 0)");
+        hasFillColor = true;
+        fill = true;
+      }
+
+      var fillColor = getAttribute(node, "fill");
+      if (fillColor) {
+        var url = iriReference.exec(fillColor);
+        if (url) {
+          // probably a gradient or pattern (or something unsupported)
+          var fillUrl = url[1];
+          var fillNode = refsHandler.getRendered(fillUrl);
+          if (fillNode && nodeIs(fillNode, "lineargradient,radialgradient")) {
+
+            // matrix to convert between gradient space and user space
+            // for "userSpaceOnUse" this is the current transformation: tfMatrix
+            // for "objectBoundingBox" or default, the gradient gets scaled and transformed to the bounding box
+            var gradientUnitsMatrix;
+            if (!fillNode.hasAttribute("gradientUnits")
+                || fillNode.getAttribute("gradientUnits").toLowerCase() === "objectboundingbox") {
+              bBox || (bBox = getUntransformedBBox(node));
+              gradientUnitsMatrix = new _pdf.Matrix(bBox[2], 0, 0, bBox[3], bBox[0], bBox[1]);
+            } else {
+              gradientUnitsMatrix = _pdf.unitMatrix;
+            }
+
+            // matrix that is applied to the gradient before any other transformations
+            var gradientTransform = parseTransform(fillNode.getAttribute("gradientTransform"));
+
+            patternOrGradient = {
+              key: fillUrl,
+              matrix: _pdf.matrixMult(gradientTransform, gradientUnitsMatrix)
+            };
+
+            fill = true;
+          } else if (fillNode && nodeIs(fillNode, "pattern")) {
+            var fillBBox, y, width, height, x;
+            patternOrGradient = { key: fillUrl };
+
+            var patternUnitsMatrix = _pdf.unitMatrix;
+            if (!fillNode.hasAttribute("patternUnits")
+                || fillNode.getAttribute("patternUnits").toLowerCase() === "objectboundingbox") {
+              bBox || (bBox = getUntransformedBBox(node));
+              patternUnitsMatrix = new _pdf.Matrix(1, 0, 0, 1, bBox[0], bBox[1]);
+
+              // TODO: slightly inaccurate (rounding errors? line width bBoxes?)
+              fillBBox = getUntransformedBBox(fillNode);
+              x = fillBBox[0] * bBox[0];
+              y = fillBBox[1] * bBox[1];
+              width = fillBBox[2] * bBox[2];
+              height = fillBBox[3] * bBox[3];
+              patternOrGradient.boundingBox = [x, y, x + width, y + height];
+              patternOrGradient.xStep = width;
+              patternOrGradient.yStep = height;
+            }
+
+            var patternContentUnitsMatrix = _pdf.unitMatrix;
+            if (fillNode.hasAttribute("patternContentUnits")
+                && fillNode.getAttribute("patternContentUnits").toLowerCase() === "objectboundingbox") {
+              bBox || (bBox = getUntransformedBBox(node));
+              patternContentUnitsMatrix = new _pdf.Matrix(bBox[2], 0, 0, bBox[3], 0, 0);
+
+              fillBBox = patternOrGradient.boundingBox || getUntransformedBBox(fillNode);
+              x = fillBBox[0] / bBox[0];
+              y = fillBBox[1] / bBox[1];
+              width = fillBBox[2] / bBox[2];
+              height = fillBBox[3] / bBox[3];
+              patternOrGradient.boundingBox = [x, y, x + width, y + height];
+              patternOrGradient.xStep = width;
+              patternOrGradient.yStep = height;
+            }
+
+            var patternTransformMatrix = _pdf.unitMatrix;
+            if (fillNode.hasAttribute("patternTransform")) {
+              patternTransformMatrix = parseTransform(fillNode.getAttribute("patternTransform"));
+            }
+
+            var matrix = patternContentUnitsMatrix;
+            matrix = _pdf.matrixMult(matrix, patternUnitsMatrix);
+            matrix = _pdf.matrixMult(matrix, patternTransformMatrix);
+            matrix = _pdf.matrixMult(matrix, tfMatrix);
+
+            patternOrGradient.matrix = matrix;
+
+            fill = true;
+          } else {
+            // unsupported fill argument -> fill black
+            setDefaultColor();
+          }
+        } else {
+          // plain color
+          fillRGB = parseColor(fillColor);
+          if (fillRGB.ok) {
+            hasFillColor = true;
+            fill = true;
+          } else {
+            fill = false;
+          }
+        }
+      }
+
+      // opacity is realized via a pdf graphics state
+      var fillOpacity = 1.0, strokeOpacity = 1.0;
+      var nodeFillOpacity = getAttribute(node, "fill-opacity");
+      if (nodeFillOpacity) {
+        fillOpacity *= parseFloat(nodeFillOpacity);
+      }
+      if (fillRGB && typeof fillRGB.a === "number") {
+        fillOpacity *= fillRGB.a;
+      }
+
+      var nodeStrokeOpacity = getAttribute(node, "stroke-opacity");
+      if (nodeStrokeOpacity) {
+        strokeOpacity *= parseFloat(nodeStrokeOpacity);
+      }
+      if (strokeRGB && typeof strokeRGB.a === "number") {
+        strokeOpacity *= strokeRGB.a;
+      }
+
+      var nodeOpacity = getAttribute(node, "opacity");
+      if (nodeOpacity) {
+        var opacity = parseFloat(nodeOpacity);
+        strokeOpacity *= opacity;
+        fillOpacity *= opacity;
+      }
+
+      var hasFillOpacity = fillOpacity < 1.0;
+      var hasStrokeOpacity = strokeOpacity < 1.0;
+      if (hasFillOpacity || hasStrokeOpacity) {
+        var gState = {};
+        hasFillOpacity && (gState["opacity"] = fillOpacity);
+        hasStrokeOpacity && (gState["stroke-opacity"] = strokeOpacity);
+        _pdf.setGState(new _pdf.GState(gState));
+      }
+
+    }
+
+    if (nodeIs(node, "g,path,rect,ellipse,line,circle,polygon,polyline")) {
+      // text has no fill color, so don't apply it until here
+      if (hasFillColor) {
+        attributeState.fill = fillRGB;
+        _pdf.setFillColor(fillRGB.r, fillRGB.g, fillRGB.b);
+      }
+
+      // stroke mode
+      var strokeColor = getAttribute(node, "stroke");
+      if (strokeColor) {
+        var strokeWidth = getAttribute(node, "stroke-width");
+        if (strokeWidth !== void 0 && strokeWidth !== "") {
+          strokeWidth = Math.abs(parseFloat(strokeWidth));
+          attributeState.strokeWidth = strokeWidth;
+          _pdf.setLineWidth(strokeWidth);
+        } else {
+          // needed for inherited zero width strokes
+          strokeWidth = attributeState.strokeWidth
+        }
+        var strokeRGB = new RGBColor(strokeColor);
+        if (strokeRGB.ok) {
+          attributeState.stroke = strokeRGB;
+          _pdf.setDrawColor(strokeRGB.r, strokeRGB.g, strokeRGB.b);
+
+          // pdf spec states: "A line width of 0 denotes the thinnest line that can be rendered at device resolution:
+          // 1 device pixel wide". SVG, however, does not draw zero width lines.
+          stroke = strokeWidth !== 0;
+        }
+        var lineCap = getAttribute(node, "stroke-linecap");
+        if (lineCap) {
+          _pdf.setLineCap(attributeState.strokeLinecap = lineCap);
+        }
+        var lineJoin = getAttribute(node, "stroke-linejoin");
+        if (lineJoin) {
+          _pdf.setLineJoin(attributeState.strokeLinejoin = lineJoin);
+        }
+        var dashArray = getAttribute(node, "stroke-dasharray");
+        if (dashArray) {
+          dashArray = parseFloats(dashArray);
+          var dashOffset = parseInt(getAttribute(node, "stroke-dashoffset")) || 0;
+          attributeState.strokeDasharray = dashArray;
+          attributeState.strokeDashoffset = dashOffset;
+          _pdf.setLineDashPattern(dashArray, dashOffset);
+        }
+        var miterLimit = getAttribute(node, "stroke-miterlimit");
+        if (miterLimit !== void 0 && miterLimit !== "") {
+          _pdf.setLineMiterLimit(attributeState.strokeMiterlimit = parseFloat(miterLimit));
+        }
+      }
+    }
+
+    // inherit fill and stroke mode if not specified at this node
+    if (fill === "inherit") {
+      fill = attributeState.fill !== null;
+    }
+    if (stroke === "inherit") {
+      stroke = attributeState.stroke !== null;
+    }
+
+    var xmlSpace = node.getAttribute("xml:space");
+    if (xmlSpace) {
+      attributeState.xmlSpace = xmlSpace;
+    }
+
+    setTextProperties(node, fillRGB, attributeState);
+    putTextProperties(attributeState, parentAttributeState);
+
+    // do the actual drawing
+    switch (node.tagName.toLowerCase()) {
+      case 'svg':
+      case 'g':
+      case 'a':
+        renderChildren(node, tfMatrix, refsHandler, withinDefs, false, attributeState);
+        break;
+
+      case 'use':
+        use(node, tfMatrix, refsHandler);
+        break;
+
+      case 'line':
+        if (!withinClipPath) {
+          _pdf.setCurrentTransformationMatrix(tfMatrix);
+          line(node, refsHandler, attributeState);
+        }
+        break;
+
+      case 'rect':
+        if (!withinClipPath) {
+          _pdf.setCurrentTransformationMatrix(tfMatrix);
+        }
+        rect(node);
+        break;
+
+      case 'ellipse':
+        if (!withinClipPath) {
+          _pdf.setCurrentTransformationMatrix(tfMatrix);
+        }
+        ellipse(node);
+        break;
+
+      case 'circle':
+        if (!withinClipPath) {
+          _pdf.setCurrentTransformationMatrix(tfMatrix);
+        }
+        circle(node);
+        break;
+      case 'text':
+        text(node, tfMatrix, hasFillColor, fillRGB, attributeState);
+        break;
+
+      case 'path':
+        if (!withinClipPath) {
+          _pdf.setCurrentTransformationMatrix(tfMatrix);
+        }
+        path(node, tfMatrix, refsHandler, withinClipPath, attributeState);
+        break;
+
+      case 'polygon':
+      case 'polyline':
+        if (!withinClipPath) {
+          _pdf.setCurrentTransformationMatrix(tfMatrix);
+        }
+        polygon(node, refsHandler, attributeState, node.tagName.toLowerCase() === "polygon");
+        break;
+
+      case 'image':
+        _pdf.setCurrentTransformationMatrix(tfMatrix);
+        image(node);
+        break;
+    }
+
+    if (nodeIs(node, "path,rect,ellipse,circle,polygon,polyline") && !withinClipPath) {
+      if (fill && stroke) {
+        _pdf.fillStroke(patternOrGradient);
+      } else if (fill) {
+        _pdf.fill(patternOrGradient);
+      } else if (stroke) {
+        _pdf.stroke();
+      } else {
+        _pdf.discardPath();
+      }
+    }
+
+    // close either the formObject or the graphics context
+    if (targetIsFormObject) {
+      _pdf.endFormObject(node.getAttribute("id"));
+    } else if (!withinClipPath) {
+      _pdf.restoreGraphicsState();
+    }
+
+    if (hasClipPath) {
+      _pdf.restoreGraphicsState();
+    }
+  };
+
+  // the actual svgToPdf function (see above)
+  var svg2pdf = function (element, pdf, options) {
+    _pdf = pdf;
+
+    var k = options.scale || 1.0,
+        xOffset = options.xOffset || 0.0,
+        yOffset = options.yOffset || 0.0;
+
+
+    _pdf.advancedAPI(function () {
+
+      // set offsets and scale everything by k
+      _pdf.saveGraphicsState();
+      _pdf.setCurrentTransformationMatrix(new _pdf.Matrix(k, 0, 0, k, xOffset, yOffset));
+
+      // set default values that differ from pdf defaults
+      var attributeState = AttributeState.default();
+      _pdf.setLineWidth(attributeState.strokeWidth);
+      var fill = attributeState.fill;
+      _pdf.setFillColor(fill.r, fill.g, fill.b);
+      _pdf.setFont(attributeState.fontFamily);
+      _pdf.setFontSize(attributeState.fontSize);
+
+
+      var refsHandler = new ReferencesHandler(element);
+      renderNode(element.cloneNode(true), _pdf.unitMatrix, refsHandler, false, false, attributeState);
+
+      _pdf.restoreGraphicsState();
+
+    });
+
+    return _pdf;
+  };
+
+  if (typeof define === "function" && define.amd) {
+    define(["./rgbcolor", "SvgPath", "font-family", "cssesc"], function (rgbcolor, svgpath, fontFamily, cssesc) {
+      RGBColor = rgbcolor;
+      SvgPath = svgpath;
+      FontFamily = fontFamily;
+      cssEsc = cssesc;
+      return svg2pdf;
+    });
+  } else if (typeof module !== "undefined" && module.exports) {
+    RGBColor = require("./rgbcolor.js");
+    SvgPath = require("SvgPath");
+    FontFamily = require("font-family");
+    cssEsc = require("cssesc");
+    module.exports = svg2pdf;
+  } else {
+    SvgPath = global.SvgPath;
+    RGBColor = global.RGBColor;
+    FontFamily = global.FontFamily;
+    cssEsc = global.cssesc;
+    global.svg2pdf = svg2pdf;
+    // for compatibility reasons
+    global.svgElementToPdf = svg2pdf;
+  }
+  return svg2pdf;
+}(typeof self !== "undefined" && self || typeof window !== "undefined" && window || this));
+
+},{"./rgbcolor.js":10,"SvgPath":1,"cssesc":8,"font-family":9}]},{},[11])(11)
+});
+//# sourceMappingURL=svg2pdf.js.map