text: 
  // @info
  //   Polyfill for SVG getPathData() and setPathData() methods. Based on:
  //   - SVGPathSeg polyfill by Philip Rogers (MIT License)
  //     https://github.com/progers/pathseg
  //   - SVGPathNormalizer by Tadahisa Motooka (MIT License)
  //     https://github.com/motooka/SVGPathNormalizer/tree/master/src
  //   - arcToCubicCurves() by Dmitry Baranovskiy (MIT License)
  //     https://github.com/DmitryBaranovskiy/raphael/blob/v2.1.1/raphael.core.js#L1837
  // @author
  //   Jarosław Foksa
  // @license
  //   MIT License
  if (!SVGPathElement.prototype.getPathData || !SVGPathElement.prototype.setPathData) {
      (function() {
          var commandsMap = {
              "Z":"Z", "M":"M", "L":"L", "C":"C", "Q":"Q", "A":"A", "H":"H", "V":"V", "S":"S", "T":"T",
              "z":"Z", "m":"m", "l":"l", "c":"c", "q":"q", "a":"a", "h":"h", "v":"v", "s":"s", "t":"t"
          };
  
          var Source = function(string) {
              this._string = string;
              this._currentIndex = 0;
              this._endIndex = this._string.length;
              this._prevCommand = null;
              this._skipOptionalSpaces();
          };
  
          var isIE = window.navigator.userAgent.indexOf("MSIE ") !== -1;
  
          Source.prototype = {
              parseSegment: function() {
                  var char = this._string[this._currentIndex];
                  var command = commandsMap[char] ? commandsMap[char] : null;
  
                  if (command === null) {
                      // Possibly an implicit command. Not allowed if this is the first command.
                      if (this._prevCommand === null) {
                          return null;
                      }
  
                      // Check for remaining coordinates in the current command.
                      if (
                          (char === "+" || char === "-" || char === "." || (char >= "0" && char <= "9")) && this._prevCommand !== "Z"
                      ) {
                          if (this._prevCommand === "M") {
                              command = "L";
                          }
                          else if (this._prevCommand === "m") {
                              command = "l";
                          }
                          else {
                              command = this._prevCommand;
                          }
                      }
                      else {
                          command = null;
                      }
  
                      if (command === null) {
                          return null;
                      }
                  }
                  else {
                      this._currentIndex += 1;
                  }
  
                  this._prevCommand = command;
  
                  var values = null;
                  var cmd = command.toUpperCase();
  
                  if (cmd === "H" || cmd === "V") {
                      values = [this._parseNumber()];
                  }
                  else if (cmd === "M" || cmd === "L" || cmd === "T") {
                      values = [this._parseNumber(), this._parseNumber()];
                  }
                  else if (cmd === "S" || cmd === "Q") {
                      values = [this._parseNumber(), this._parseNumber(), this._parseNumber(), this._parseNumber()];
                  }
                  else if (cmd === "C") {
                      values = [
                          this._parseNumber(),
                          this._parseNumber(),
                          this._parseNumber(),
                          this._parseNumber(),
                          this._parseNumber(),
                          this._parseNumber()
                      ];
                  }
                  else if (cmd === "A") {
                      values = [
                          this._parseNumber(),
                          this._parseNumber(),
                          this._parseNumber(),
                          this._parseArcFlag(),
                          this._parseArcFlag(),
                          this._parseNumber(),
                          this._parseNumber()
                      ];
                  }
                  else if (cmd === "Z") {
                      this._skipOptionalSpaces();
                      values = [];
                  }
  
                  if (values === null || values.indexOf(null) >= 0) {
                      // Unknown command or known command with invalid values
                      return null;
                  }
                  else {
                      return {type: command, values: values};
                  }
              },
  
              hasMoreData: function() {
                  return this._currentIndex < this._endIndex;
              },
  
              peekSegmentType: function() {
                  var char = this._string[this._currentIndex];
                  return commandsMap[char] ? commandsMap[char] : null;
              },
  
              initialCommandIsMoveTo: function() {
                  // If the path is empty it is still valid, so return true.
                  if (!this.hasMoreData()) {
                      return true;
                  }
  
                  var command = this.peekSegmentType();
                  // Path must start with moveTo.
                  return command === "M" || command === "m";
              },
  
              _isCurrentSpace: function() {
                  var char = this._string[this._currentIndex];
                  return char <= " " && (char === " " || char === "\n" || char === "\t" || char === "\r" || char === "\f");
              },
  
              _skipOptionalSpaces: function() {
                  while (this._currentIndex < this._endIndex && this._isCurrentSpace()) {
                      this._currentIndex += 1;
                  }
  
                  return this._currentIndex < this._endIndex;
              },
  
              _skipOptionalSpacesOrDelimiter: function() {
                  if (
                      this._currentIndex < this._endIndex &&
                      !this._isCurrentSpace() &&
                      this._string[this._currentIndex] !== ","
                  ) {
                      return false;
                  }
  
                  if (this._skipOptionalSpaces()) {
                      if (this._currentIndex < this._endIndex && this._string[this._currentIndex] === ",") {
                          this._currentIndex += 1;
                          this._skipOptionalSpaces();
                      }
                  }
                  return this._currentIndex < this._endIndex;
              },
  
              // Parse a number from an SVG path. This very closely follows genericParseNumber(...) from
              // Source/core/svg/SVGParserUtilities.cpp.
              // Spec: http://www.w3.org/TR/SVG11/single-page.html#paths-PathDataBNF
              _parseNumber: function() {
                  var exponent = 0;
                  var integer = 0;
                  var frac = 1;
                  var decimal = 0;
                  var sign = 1;
                  var expsign = 1;
                  var startIndex = this._currentIndex;
  
                  this._skipOptionalSpaces();
  
                  // Read the sign.
                  if (this._currentIndex < this._endIndex && this._string[this._currentIndex] === "+") {
                      this._currentIndex += 1;
                  }
                  else if (this._currentIndex < this._endIndex && this._string[this._currentIndex] === "-") {
                      this._currentIndex += 1;
                      sign = -1;
                  }
  
                  if (
                      this._currentIndex === this._endIndex ||
                      (
                          (this._string[this._currentIndex] < "0" || this._string[this._currentIndex] > "9") &&
                          this._string[this._currentIndex] !== "."
                      )
                  ) {
                      // The first character of a number must be one of [0-9+-.].
                      return null;
                  }
  
                  // Read the integer part, build right-to-left.
                  var startIntPartIndex = this._currentIndex;
  
                  while (
                      this._currentIndex < this._endIndex &&
                      this._string[this._currentIndex] >= "0" &&
                      this._string[this._currentIndex] <= "9"
                      ) {
                      this._currentIndex += 1; // Advance to first non-digit.
                  }
  
                  if (this._currentIndex !== startIntPartIndex) {
                      var scanIntPartIndex = this._currentIndex - 1;
                      var multiplier = 1;
  
                      while (scanIntPartIndex >= startIntPartIndex) {
                          integer += multiplier * (this._string[scanIntPartIndex] - "0");
                          scanIntPartIndex -= 1;
                          multiplier *= 10;
                      }
                  }
  
                  // Read the decimals.
                  if (this._currentIndex < this._endIndex && this._string[this._currentIndex] === ".") {
                      this._currentIndex += 1;
  
                      // There must be a least one digit following the .
                      if (
                          this._currentIndex >= this._endIndex ||
                          this._string[this._currentIndex] < "0" ||
                          this._string[this._currentIndex] > "9"
                      ) {
                          return null;
                      }
  
                      while (
                          this._currentIndex < this._endIndex &&
                          this._string[this._currentIndex] >= "0" &&
                          this._string[this._currentIndex] <= "9"
                          ) {
                          frac *= 10;
                          decimal += (this._string.charAt(this._currentIndex) - "0") / frac;
                          this._currentIndex += 1;
                      }
                  }
  
                  // Read the exponent part.
                  if (
                      this._currentIndex !== startIndex &&
                      this._currentIndex + 1 < this._endIndex &&
                      (this._string[this._currentIndex] === "e" || this._string[this._currentIndex] === "E") &&
                      (this._string[this._currentIndex + 1] !== "x" && this._string[this._currentIndex + 1] !== "m")
                  ) {
                      this._currentIndex += 1;
  
                      // Read the sign of the exponent.
                      if (this._string[this._currentIndex] === "+") {
                          this._currentIndex += 1;
                      }
                      else if (this._string[this._currentIndex] === "-") {
                          this._currentIndex += 1;
                          expsign = -1;
                      }
  
                      // There must be an exponent.
                      if (
                          this._currentIndex >= this._endIndex ||
                          this._string[this._currentIndex] < "0" ||
                          this._string[this._currentIndex] > "9"
                      ) {
                          return null;
                      }
  
                      while (
                          this._currentIndex < this._endIndex &&
                          this._string[this._currentIndex] >= "0" &&
                          this._string[this._currentIndex] <= "9"
                          ) {
                          exponent *= 10;
                          exponent += (this._string[this._currentIndex] - "0");
                          this._currentIndex += 1;
                      }
                  }
  
                  var number = integer + decimal;
                  number *= sign;
  
                  if (exponent) {
                      number *= Math.pow(10, expsign * exponent);
                  }
  
                  if (startIndex === this._currentIndex) {
                      return null;
                  }
  
                  this._skipOptionalSpacesOrDelimiter();
  
                  return number;
              },
  
              _parseArcFlag: function() {
                  if (this._currentIndex >= this._endIndex) {
                      return null;
                  }
  
                  var flag = null;
                  var flagChar = this._string[this._currentIndex];
  
                  this._currentIndex += 1;
  
                  if (flagChar === "0") {
                      flag = 0;
                  }
                  else if (flagChar === "1") {
                      flag = 1;
                  }
                  else {
                      return null;
                  }
  
                  this._skipOptionalSpacesOrDelimiter();
                  return flag;
              }
          };
  
          var parsePathDataString = function(string) {
              if (!string || string.length === 0) return [];
  
              var source = new Source(string);
              var pathData = [];
  
              if (source.initialCommandIsMoveTo()) {
                  while (source.hasMoreData()) {
                      var pathSeg = source.parseSegment();
  
                      if (pathSeg === null) {
                          break;
                      }
                      else {
                          pathData.push(pathSeg);
                      }
                  }
              }
  
              return pathData;
          }
  
          var setAttribute = SVGPathElement.prototype.setAttribute;
          var removeAttribute = SVGPathElement.prototype.removeAttribute;
  
          var $cachedPathData = window.Symbol ? Symbol() : "__cachedPathData";
          var $cachedNormalizedPathData = window.Symbol ? Symbol() : "__cachedNormalizedPathData";
  
          // @info
          //   Get an array of corresponding cubic bezier curve parameters for given arc curve paramters.
          var arcToCubicCurves = function(x1, y1, x2, y2, r1, r2, angle, largeArcFlag, sweepFlag, _recursive) {
              var degToRad = function(degrees) {
                  return (Math.PI * degrees) / 180;
              };
  
              var rotate = function(x, y, angleRad) {
                  var X = x * Math.cos(angleRad) - y * Math.sin(angleRad);
                  var Y = x * Math.sin(angleRad) + y * Math.cos(angleRad);
                  return {x: X, y: Y};
              };
  
              var angleRad = degToRad(angle);
              var params = [];
              var f1, f2, cx, cy;
  
              if (_recursive) {
                  f1 = _recursive[0];
                  f2 = _recursive[1];
                  cx = _recursive[2];
                  cy = _recursive[3];
              }
              else {
                  var p1 = rotate(x1, y1, -angleRad);
                  x1 = p1.x;
                  y1 = p1.y;
  
                  var p2 = rotate(x2, y2, -angleRad);
                  x2 = p2.x;
                  y2 = p2.y;
  
                  var x = (x1 - x2) / 2;
                  var y = (y1 - y2) / 2;
                  var h = (x * x) / (r1 * r1) + (y * y) / (r2 * r2);
  
                  if (h > 1) {
                      h = Math.sqrt(h);
                      r1 = h * r1;
                      r2 = h * r2;
                  }
  
                  var sign;
  
                  if (largeArcFlag === sweepFlag) {
                      sign = -1;
                  }
                  else {
                      sign = 1;
                  }
  
                  var r1Pow = r1 * r1;
                  var r2Pow = r2 * r2;
  
                  var left = r1Pow * r2Pow - r1Pow * y * y - r2Pow * x * x;
                  var right = r1Pow * y * y + r2Pow * x * x;
  
                  var k = sign * Math.sqrt(Math.abs(left/right));
  
                  cx = k * r1 * y / r2 + (x1 + x2) / 2;
                  cy = k * -r2 * x / r1 + (y1 + y2) / 2;
  
                  f1 = Math.asin(parseFloat(((y1 - cy) / r2).toFixed(9)));
                  f2 = Math.asin(parseFloat(((y2 - cy) / r2).toFixed(9)));
  
                  if (x1 < cx) {
                      f1 = Math.PI - f1;
                  }
                  if (x2 < cx) {
                      f2 = Math.PI - f2;
                  }
  
                  if (f1 < 0) {
                      f1 = Math.PI * 2 + f1;
                  }
                  if (f2 < 0) {
                      f2 = Math.PI * 2 + f2;
                  }
  
                  if (sweepFlag && f1 > f2) {
                      f1 = f1 - Math.PI * 2;
                  }
                  if (!sweepFlag && f2 > f1) {
                      f2 = f2 - Math.PI * 2;
                  }
              }
  
              var df = f2 - f1;
  
              if (Math.abs(df) > (Math.PI * 120 / 180)) {
                  var f2old = f2;
                  var x2old = x2;
                  var y2old = y2;
  
                  if (sweepFlag && f2 > f1) {
                      f2 = f1 + (Math.PI * 120 / 180) * (1);
                  }
                  else {
                      f2 = f1 + (Math.PI * 120 / 180) * (-1);
                  }
  
                  x2 = cx + r1 * Math.cos(f2);
                  y2 = cy + r2 * Math.sin(f2);
                  params = arcToCubicCurves(x2, y2, x2old, y2old, r1, r2, angle, 0, sweepFlag, [f2, f2old, cx, cy]);
              }
  
              df = f2 - f1;
  
              var c1 = Math.cos(f1);
              var s1 = Math.sin(f1);
              var c2 = Math.cos(f2);
              var s2 = Math.sin(f2);
              var t = Math.tan(df / 4);
              var hx = 4 / 3 * r1 * t;
              var hy = 4 / 3 * r2 * t;
  
              var m1 = [x1, y1];
              var m2 = [x1 + hx * s1, y1 - hy * c1];
              var m3 = [x2 + hx * s2, y2 - hy * c2];
              var m4 = [x2, y2];
  
              m2[0] = 2 * m1[0] - m2[0];
              m2[1] = 2 * m1[1] - m2[1];
  
              if (_recursive) {
                  return [m2, m3, m4].concat(params);
              }
              else {
                  params = [m2, m3, m4].concat(params);
  
                  var curves = [];
  
                  for (var i = 0; i < params.length; i+=3) {
                      var r1 = rotate(params[i][0], params[i][1], angleRad);
                      var r2 = rotate(params[i+1][0], params[i+1][1], angleRad);
                      var r3 = rotate(params[i+2][0], params[i+2][1], angleRad);
                      curves.push([r1.x, r1.y, r2.x, r2.y, r3.x, r3.y]);
                  }
  
                  return curves;
              }
          };
  
          var clonePathData = function(pathData) {
              return pathData.map( function(seg) {
                  return {type: seg.type, values: Array.prototype.slice.call(seg.values)}
              });
          };
  
          // @info
          //   Takes any path data, returns path data that consists only from absolute commands.
          var absolutizePathData = function(pathData) {
              var absolutizedPathData = [];
  
              var currentX = null;
              var currentY = null;
  
              var subpathX = null;
              var subpathY = null;
  
              pathData.forEach( function(seg) {
                  var type = seg.type;
  
                  if (type === "M") {
                      var x = seg.values[0];
                      var y = seg.values[1];
  
                      absolutizedPathData.push({type: "M", values: [x, y]});
  
                      subpathX = x;
                      subpathY = y;
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (type === "m") {
                      var x = currentX + seg.values[0];
                      var y = currentY + seg.values[1];
  
                      absolutizedPathData.push({type: "M", values: [x, y]});
  
                      subpathX = x;
                      subpathY = y;
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (type === "L") {
                      var x = seg.values[0];
                      var y = seg.values[1];
  
                      absolutizedPathData.push({type: "L", values: [x, y]});
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (type === "l") {
                      var x = currentX + seg.values[0];
                      var y = currentY + seg.values[1];
  
                      absolutizedPathData.push({type: "L", values: [x, y]});
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (type === "C") {
                      var x1 = seg.values[0];
                      var y1 = seg.values[1];
                      var x2 = seg.values[2];
                      var y2 = seg.values[3];
                      var x = seg.values[4];
                      var y = seg.values[5];
  
                      absolutizedPathData.push({type: "C", values: [x1, y1, x2, y2, x, y]});
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (type === "c") {
                      var x1 = currentX + seg.values[0];
                      var y1 = currentY + seg.values[1];
                      var x2 = currentX + seg.values[2];
                      var y2 = currentY + seg.values[3];
                      var x = currentX + seg.values[4];
                      var y = currentY + seg.values[5];
  
                      absolutizedPathData.push({type: "C", values: [x1, y1, x2, y2, x, y]});
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (type === "Q") {
                      var x1 = seg.values[0];
                      var y1 = seg.values[1];
                      var x = seg.values[2];
                      var y = seg.values[3];
  
                      absolutizedPathData.push({type: "Q", values: [x1, y1, x, y]});
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (type === "q") {
                      var x1 = currentX + seg.values[0];
                      var y1 = currentY + seg.values[1];
                      var x = currentX + seg.values[2];
                      var y = currentY + seg.values[3];
  
                      absolutizedPathData.push({type: "Q", values: [x1, y1, x, y]});
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (type === "A") {
                      var x = seg.values[5];
                      var y = seg.values[6];
  
                      absolutizedPathData.push({
                          type: "A",
                          values: [seg.values[0], seg.values[1], seg.values[2], seg.values[3], seg.values[4], x, y]
                      });
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (type === "a") {
                      var x = currentX + seg.values[5];
                      var y = currentY + seg.values[6];
  
                      absolutizedPathData.push({
                          type: "A",
                          values: [seg.values[0], seg.values[1], seg.values[2], seg.values[3], seg.values[4], x, y]
                      });
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (type === "H") {
                      var x = seg.values[0];
                      absolutizedPathData.push({type: "H", values: [x]});
                      currentX = x;
                  }
  
                  else if (type === "h") {
                      var x = currentX + seg.values[0];
                      absolutizedPathData.push({type: "H", values: [x]});
                      currentX = x;
                  }
  
                  else if (type === "V") {
                      var y = seg.values[0];
                      absolutizedPathData.push({type: "V", values: [y]});
                      currentY = y;
                  }
  
                  else if (type === "v") {
                      var y = currentY + seg.values[0];
                      absolutizedPathData.push({type: "V", values: [y]});
                      currentY = y;
                  }
  
                  else if (type === "S") {
                      var x2 = seg.values[0];
                      var y2 = seg.values[1];
                      var x = seg.values[2];
                      var y = seg.values[3];
  
                      absolutizedPathData.push({type: "S", values: [x2, y2, x, y]});
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (type === "s") {
                      var x2 = currentX + seg.values[0];
                      var y2 = currentY + seg.values[1];
                      var x = currentX + seg.values[2];
                      var y = currentY + seg.values[3];
  
                      absolutizedPathData.push({type: "S", values: [x2, y2, x, y]});
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (type === "T") {
                      var x = seg.values[0];
                      var y = seg.values[1]
  
                      absolutizedPathData.push({type: "T", values: [x, y]});
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (type === "t") {
                      var x = currentX + seg.values[0];
                      var y = currentY + seg.values[1]
  
                      absolutizedPathData.push({type: "T", values: [x, y]});
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (type === "Z" || type === "z") {
                      absolutizedPathData.push({type: "Z", values: []});
  
                      currentX = subpathX;
                      currentY = subpathY;
                  }
              });
  
              return absolutizedPathData;
          };
  
          // @info
          //   Takes path data that consists only from absolute commands, returns path data that consists only from
          //   "M", "L", "C" and "Z" commands.
          var reducePathData = function(pathData) {
              var reducedPathData = [];
              var lastType = null;
  
              var lastControlX = null;
              var lastControlY = null;
  
              var currentX = null;
              var currentY = null;
  
              var subpathX = null;
              var subpathY = null;
  
              pathData.forEach( function(seg) {
                  if (seg.type === "M") {
                      var x = seg.values[0];
                      var y = seg.values[1];
  
                      reducedPathData.push({type: "M", values: [x, y]});
  
                      subpathX = x;
                      subpathY = y;
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (seg.type === "C") {
                      var x1 = seg.values[0];
                      var y1 = seg.values[1];
                      var x2 = seg.values[2];
                      var y2 = seg.values[3];
                      var x = seg.values[4];
                      var y = seg.values[5];
  
                      reducedPathData.push({type: "C", values: [x1, y1, x2, y2, x, y]});
  
                      lastControlX = x2;
                      lastControlY = y2;
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (seg.type === "L") {
                      var x = seg.values[0];
                      var y = seg.values[1];
  
                      reducedPathData.push({type: "L", values: [x, y]});
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (seg.type === "H") {
                      var x = seg.values[0];
  
                      reducedPathData.push({type: "L", values: [x, currentY]});
  
                      currentX = x;
                  }
  
                  else if (seg.type === "V") {
                      var y = seg.values[0];
  
                      reducedPathData.push({type: "L", values: [currentX, y]});
  
                      currentY = y;
                  }
  
                  else if (seg.type === "S") {
                      var x2 = seg.values[0];
                      var y2 = seg.values[1];
                      var x = seg.values[2];
                      var y = seg.values[3];
  
                      var cx1, cy1;
  
                      if (lastType === "C" || lastType === "S") {
                          cx1 = currentX + (currentX - lastControlX);
                          cy1 = currentY + (currentY - lastControlY);
                      }
                      else {
                          cx1 = currentX;
                          cy1 = currentY;
                      }
  
                      reducedPathData.push({type: "C", values: [cx1, cy1, x2, y2, x, y]});
  
                      lastControlX = x2;
                      lastControlY = y2;
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (seg.type === "T") {
                      var x = seg.values[0];
                      var y = seg.values[1];
  
                      var x1, y1;
  
                      if (lastType === "Q" || lastType === "T") {
                          x1 = currentX + (currentX - lastControlX);
                          y1 = currentY + (currentY - lastControlY);
                      }
                      else {
                          x1 = currentX;
                          y1 = currentY;
                      }
  
                      var cx1 = currentX + 2 * (x1 - currentX) / 3;
                      var cy1 = currentY + 2 * (y1 - currentY) / 3;
                      var cx2 = x + 2 * (x1 - x) / 3;
                      var cy2 = y + 2 * (y1 - y) / 3;
  
                      reducedPathData.push({type: "C", values: [cx1, cy1, cx2, cy2, x, y]});
  
                      lastControlX = x1;
                      lastControlY = y1;
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (seg.type === "Q") {
                      var x1 = seg.values[0];
                      var y1 = seg.values[1];
                      var x = seg.values[2];
                      var y = seg.values[3];
  
                      var cx1 = currentX + 2 * (x1 - currentX) / 3;
                      var cy1 = currentY + 2 * (y1 - currentY) / 3;
                      var cx2 = x + 2 * (x1 - x) / 3;
                      var cy2 = y + 2 * (y1 - y) / 3;
  
                      reducedPathData.push({type: "C", values: [cx1, cy1, cx2, cy2, x, y]});
  
                      lastControlX = x1;
                      lastControlY = y1;
  
                      currentX = x;
                      currentY = y;
                  }
  
                  else if (seg.type === "A") {
                      var r1 = Math.abs(seg.values[0]);
                      var r2 = Math.abs(seg.values[1]);
                      var angle = seg.values[2];
                      var largeArcFlag = seg.values[3];
                      var sweepFlag = seg.values[4];
                      var x = seg.values[5];
                      var y = seg.values[6];
  
                      if (r1 === 0 || r2 === 0) {
                          reducedPathData.push({type: "C", values: [currentX, currentY, x, y, x, y]});
  
                          currentX = x;
                          currentY = y;
                      }
                      else {
                          if (currentX !== x || currentY !== y) {
                              var curves = arcToCubicCurves(currentX, currentY, x, y, r1, r2, angle, largeArcFlag, sweepFlag);
  
                              curves.forEach( function(curve) {
                                  reducedPathData.push({type: "C", values: curve});
                              });
  
                              currentX = x;
                              currentY = y;
                          }
                      }
                  }
  
                  else if (seg.type === "Z") {
                      reducedPathData.push(seg);
  
                      currentX = subpathX;
                      currentY = subpathY;
                  }
  
                  lastType = seg.type;
              });
  
              return reducedPathData;
          };
  
          SVGPathElement.prototype.setAttribute = function(name, value) {
              if (name === "d") {
                  this[$cachedPathData] = null;
                  this[$cachedNormalizedPathData] = null;
              }
  
              setAttribute.call(this, name, value);
          };
  
          SVGPathElement.prototype.removeAttribute = function(name, value) {
              if (name === "d") {
                  this[$cachedPathData] = null;
                  this[$cachedNormalizedPathData] = null;
              }
  
              removeAttribute.call(this, name);
          };
  
          SVGPathElement.prototype.getPathData = function(options) {
              if (options && options.normalize) {
                  if (this[$cachedNormalizedPathData]) {
                      return clonePathData(this[$cachedNormalizedPathData]);
                  }
                  else {
                      var pathData;
  
                      if (this[$cachedPathData]) {
                          pathData = clonePathData(this[$cachedPathData]);
                      }
                      else {
                          pathData = parsePathDataString(this.getAttribute("d") || "");
                          this[$cachedPathData] = clonePathData(pathData);
                      }
  
                      var normalizedPathData = reducePathData(absolutizePathData(pathData));
                      this[$cachedNormalizedPathData] = clonePathData(normalizedPathData);
                      return normalizedPathData;
                  }
              }
              else {
                  if (this[$cachedPathData]) {
                      return clonePathData(this[$cachedPathData]);
                  }
                  else {
                      var pathData = parsePathDataString(this.getAttribute("d") || "");
                      this[$cachedPathData] = clonePathData(pathData);
                      return pathData;
                  }
              }
          };
  
          SVGPathElement.prototype.setPathData = function(pathData) {
              if (pathData.length === 0) {
                  if (isIE) {
                      // @bugfix https://github.com/mbostock/d3/issues/1737
                      this.setAttribute("d", "");
                  }
                  else {
                      this.removeAttribute("d");
                  }
              }
              else {
                  var d = "";
  
                  for (var i = 0, l = pathData.length; i < l; i += 1) {
                      var seg = pathData[i];
  
                      if (i > 0) {
                          d += " ";
                      }
  
                      d += seg.type;
  
                      if (seg.values && seg.values.length > 0) {
                          d += " " + seg.values.join(" ");
                      }
                  }
  
                  this.setAttribute("d", d);
              }
          };
  
          SVGRectElement.prototype.getPathData = function(options) {
              var x = this.x.baseVal.value;
              var y = this.y.baseVal.value;
              var width = this.width.baseVal.value;
              var height = this.height.baseVal.value;
              var rx = this.hasAttribute("rx") ? this.rx.baseVal.value : this.ry.baseVal.value;
              var ry = this.hasAttribute("ry") ? this.ry.baseVal.value : this.rx.baseVal.value;
  
              if (rx > width / 2) {
                  rx = width / 2;
              }
  
              if (ry > height / 2) {
                  ry = height / 2;
              }
  
              var pathData = [
                  {type: "M", values: [x+rx, y]},
                  {type: "H", values: [x+width-rx]},
                  {type: "A", values: [rx, ry, 0, 0, 1, x+width, y+ry]},
                  {type: "V", values: [y+height-ry]},
                  {type: "A", values: [rx, ry, 0, 0, 1, x+width-rx, y+height]},
                  {type: "H", values: [x+rx]},
                  {type: "A", values: [rx, ry, 0, 0, 1, x, y+height-ry]},
                  {type: "V", values: [y+ry]},
                  {type: "A", values: [rx, ry, 0, 0, 1, x+rx, y]},
                  {type: "Z", values: []}
              ];
  
              // Get rid of redundant "A" segs when either rx or ry is 0
              pathData = pathData.filter(function(s) {
                  return s.type === "A" && (s.values[0] === 0 || s.values[1] === 0) ? false : true;
              });
  
              if (options && options.normalize === true) {
                  pathData = reducePathData(pathData);
              }
  
              return pathData;
          };
  
          SVGCircleElement.prototype.getPathData = function(options) {
              var cx = this.cx.baseVal.value;
              var cy = this.cy.baseVal.value;
              var r = this.r.baseVal.value;
  
              var pathData = [
                  { type: "M",  values: [cx + r, cy] },
                  { type: "A",  values: [r, r, 0, 0, 1, cx, cy+r] },
                  { type: "A",  values: [r, r, 0, 0, 1, cx-r, cy] },
                  { type: "A",  values: [r, r, 0, 0, 1, cx, cy-r] },
                  { type: "A",  values: [r, r, 0, 0, 1, cx+r, cy] },
                  { type: "Z",  values: [] }
              ];
  
              if (options && options.normalize === true) {
                  pathData = reducePathData(pathData);
              }
  
              return pathData;
          };
  
          SVGEllipseElement.prototype.getPathData = function(options) {
              var cx = this.cx.baseVal.value;
              var cy = this.cy.baseVal.value;
              var rx = this.rx.baseVal.value;
              var ry = this.ry.baseVal.value;
  
              var pathData = [
                  { type: "M",  values: [cx + rx, cy] },
                  { type: "A",  values: [rx, ry, 0, 0, 1, cx, cy+ry] },
                  { type: "A",  values: [rx, ry, 0, 0, 1, cx-rx, cy] },
                  { type: "A",  values: [rx, ry, 0, 0, 1, cx, cy-ry] },
                  { type: "A",  values: [rx, ry, 0, 0, 1, cx+rx, cy] },
                  { type: "Z",  values: [] }
              ];
  
              if (options && options.normalize === true) {
                  pathData = reducePathData(pathData);
              }
  
              return pathData;
          };
  
          SVGLineElement.prototype.getPathData = function() {
              return [
                  { type: "M", values: [this.x1.baseVal.value, this.y1.baseVal.value] },
                  { type: "L", values: [this.x2.baseVal.value, this.y2.baseVal.value] }
              ];
          };
  
          SVGPolylineElement.prototype.getPathData = function() {
              var pathData = [];
  
              for (var i = 0; i < this.points.numberOfItems; i += 1) {
                  var point = this.points.getItem(i);
  
                  pathData.push({
                      type: (i === 0 ? "M" : "L"),
                      values: [point.x, point.y]
                  });
              }
  
              return pathData;
          };
  
          SVGPolygonElement.prototype.getPathData = function() {
              var pathData = [];
  
              for (var i = 0; i < this.points.numberOfItems; i += 1) {
                  var point = this.points.getItem(i);
  
                  pathData.push({
                      type: (i === 0 ? "M" : "L"),
                      values: [point.x, point.y]
                  });
              }
  
              pathData.push({
                  type: "Z",
                  values: []
              });
  
              return pathData;
          };
      })();
  }
  