client-data/js/path-data-polyfill.js

// @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
(function () {
  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;
  };

  // @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;
    }
  };

  let isPathDataSupported =
    SVGPathElement.prototype.getPathData !== undefined &&
    SVGPathElement.prototype.setPathData !== undefined;

  // Apply the polyfill if the native implementation of setPathData() accepts only SVGPathSegment instances
  // https://github.com/w3c/svgwg/issues/974
  // https://github.com/w3c/editing/issues/483
  // https://bugzilla.mozilla.org/show_bug.cgi?id=1954044#c18
  if (isPathDataSupported) {
    try {
      document
        .createElementNS("http://www.w3.org/2000/svg", "path")
        .setPathData([{ type: "M", values: [0, 0] }]);
    } catch (error) {
      isPathDataSupported = false;
    }
  }

  if (isPathDataSupported === false) {
    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 setAttributeNS = SVGPathElement.prototype.setAttributeNS;
    var removeAttribute = SVGPathElement.prototype.removeAttribute;
    var removeAttributeNS = SVGPathElement.prototype.removeAttributeNS;

    var $cachedPathData = window.Symbol ? Symbol() : "__cachedPathData";
    var $cachedNormalizedPathData = window.Symbol
      ? Symbol()
      : "__cachedNormalizedPathData";

    SVGPathElement.prototype.setAttribute = function (name, value) {
      if (name === "d") {
        this[$cachedPathData] = null;
        this[$cachedNormalizedPathData] = null;
      }

      setAttribute.call(this, name, value);
    };

    SVGPathElement.prototype.setAttributeNS = function (
      namespace,
      name,
      value,
    ) {
      if (name === "d") {
        var namespaceURI = "http://www.w3.org/2000/svg";

        if (namespace) {
          for (var attribute of this.ownerSVGElement.attributes) {
            if (attribute.name === `xmlns:${namespace}`) {
              namespaceURI = attribute.value;
            }
          }
        }

        if (namespaceURI === "http://www.w3.org/2000/svg") {
          this[$cachedPathData] = null;
          this[$cachedNormalizedPathData] = null;
        }
      }

      setAttributeNS.call(this, namespace, name, value);
    };

    SVGPathElement.prototype.removeAttribute = function (name, value) {
      if (name === "d") {
        this[$cachedPathData] = null;
        this[$cachedNormalizedPathData] = null;
      }

      removeAttribute.call(this, name);
    };

    SVGPathElement.prototype.removeAttributeNS = function (namespace, name) {
      if (name === "d") {
        var namespaceURI = "http://www.w3.org/2000/svg";

        if (namespace) {
          for (var attribute of this.ownerSVGElement.attributes) {
            if (attribute.name === `xmlns:${namespace}`) {
              namespaceURI = attribute.value;
            }
          }
        }

        if (namespaceURI === "http://www.w3.org/2000/svg") {
          this[$cachedPathData] = null;
          this[$cachedNormalizedPathData] = null;
        }
      }

      removeAttributeNS.call(this, namespace, 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);
      }
    };
  }

  if (!SVGRectElement.prototype.getPathData) {
    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;
    };
  }

  if (!SVGCircleElement.prototype.getPathData) {
    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;
    };
  }

  if (!SVGEllipseElement.prototype.getPathData) {
    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;
    };
  }

  if (!SVGLineElement.prototype.getPathData) {
    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] },
      ];
    };
  }

  if (!SVGPolylineElement.prototype.getPathData) {
    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;
    };
  }

  if (!SVGPolygonElement.prototype.getPathData) {
    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;
    };
  }
})();