sketchicon 0.1.0

package/dist/chunk-F6H33SNU.js

@@ -0,0 +1,1424 @@
+// ../core/src/primitives.ts
+var KAPPA = 0.5522847498;
+function ellipsePath(cx, cy, rx, ry) {
+  const ox = rx * KAPPA;
+  const oy = ry * KAPPA;
+  return [
+    `M${cx - rx} ${cy}`,
+    `C${cx - rx} ${cy - oy} ${cx - ox} ${cy - ry} ${cx} ${cy - ry}`,
+    `C${cx + ox} ${cy - ry} ${cx + rx} ${cy - oy} ${cx + rx} ${cy}`,
+    `C${cx + rx} ${cy + oy} ${cx + ox} ${cy + ry} ${cx} ${cy + ry}`,
+    `C${cx - ox} ${cy + ry} ${cx - rx} ${cy + oy} ${cx - rx} ${cy}Z`
+  ].join("");
+}
+function pointsPath(points, close) {
+  if (points.length < 4 || points.length % 2 !== 0) {
+    throw new Error("Polyline and polygon points must contain at least two coordinate pairs.");
+  }
+  let path = `M${points[0]} ${points[1]}`;
+  for (let index = 2; index < points.length; index += 2) {
+    path += `L${points[index]} ${points[index + 1]}`;
+  }
+  return close ? `${path}Z` : path;
+}
+function rectPath(primitive) {
+  const { x, y, width, height } = primitive;
+  const requestedRx = primitive.rx ?? primitive.ry ?? 0;
+  const requestedRy = primitive.ry ?? primitive.rx ?? 0;
+  const rx = Math.max(0, Math.min(requestedRx, width / 2));
+  const ry = Math.max(0, Math.min(requestedRy, height / 2));
+  if (rx === 0 || ry === 0) {
+    return `M${x} ${y}H${x + width}V${y + height}H${x}Z`;
+  }
+  return [
+    `M${x + rx} ${y}`,
+    `H${x + width - rx}`,
+    `Q${x + width} ${y} ${x + width} ${y + ry}`,
+    `V${y + height - ry}`,
+    `Q${x + width} ${y + height} ${x + width - rx} ${y + height}`,
+    `H${x + rx}`,
+    `Q${x} ${y + height} ${x} ${y + height - ry}`,
+    `V${y + ry}`,
+    `Q${x} ${y} ${x + rx} ${y}Z`
+  ].join("");
+}
+function primitiveToPath(primitive) {
+  switch (primitive.type) {
+    case "path":
+      return primitive.d;
+    case "line":
+      return `M${primitive.x1} ${primitive.y1}L${primitive.x2} ${primitive.y2}`;
+    case "polyline":
+      return pointsPath(primitive.points, false);
+    case "polygon":
+      return pointsPath(primitive.points, true);
+    case "circle":
+      return ellipsePath(primitive.cx, primitive.cy, primitive.r, primitive.r);
+    case "ellipse":
+      return ellipsePath(primitive.cx, primitive.cy, primitive.rx, primitive.ry);
+    case "rect":
+      return rectPath(primitive);
+  }
+}
+
+// ../../node_modules/svg-pathdata/dist/SVGPathDataEncoder.js
+var WSP = " ";
+function encodeSVGPath(commands) {
+  let str = "";
+  if (!Array.isArray(commands)) {
+    commands = [commands];
+  }
+  for (let i = 0; i < commands.length; i++) {
+    const command = commands[i];
+    if (command.type === SVGPathData.CLOSE_PATH) {
+      str += "z";
+    } else if (command.type === SVGPathData.HORIZ_LINE_TO) {
+      str += (command.relative ? "h" : "H") + command.x;
+    } else if (command.type === SVGPathData.VERT_LINE_TO) {
+      str += (command.relative ? "v" : "V") + command.y;
+    } else if (command.type === SVGPathData.MOVE_TO) {
+      str += (command.relative ? "m" : "M") + command.x + WSP + command.y;
+    } else if (command.type === SVGPathData.LINE_TO) {
+      str += (command.relative ? "l" : "L") + command.x + WSP + command.y;
+    } else if (command.type === SVGPathData.CURVE_TO) {
+      str += (command.relative ? "c" : "C") + command.x1 + WSP + command.y1 + WSP + command.x2 + WSP + command.y2 + WSP + command.x + WSP + command.y;
+    } else if (command.type === SVGPathData.SMOOTH_CURVE_TO) {
+      str += (command.relative ? "s" : "S") + command.x2 + WSP + command.y2 + WSP + command.x + WSP + command.y;
+    } else if (command.type === SVGPathData.QUAD_TO) {
+      str += (command.relative ? "q" : "Q") + command.x1 + WSP + command.y1 + WSP + command.x + WSP + command.y;
+    } else if (command.type === SVGPathData.SMOOTH_QUAD_TO) {
+      str += (command.relative ? "t" : "T") + command.x + WSP + command.y;
+    } else if (command.type === SVGPathData.ARC) {
+      str += (command.relative ? "a" : "A") + command.rX + WSP + command.rY + WSP + command.xRot + WSP + +command.lArcFlag + WSP + +command.sweepFlag + WSP + command.x + WSP + command.y;
+    } else {
+      throw new Error(`Unexpected command type "${command?.type}" at index ${i}.`);
+    }
+  }
+  return str;
+}
+
+// ../../node_modules/svg-pathdata/dist/mathUtils.js
+function rotate([x, y], rad) {
+  return [
+    x * Math.cos(rad) - y * Math.sin(rad),
+    x * Math.sin(rad) + y * Math.cos(rad)
+  ];
+}
+var DEBUG_CHECK_NUMBERS = true;
+function assertNumbers(...numbers) {
+  if (DEBUG_CHECK_NUMBERS) {
+    for (let i = 0; i < numbers.length; i++) {
+      if ("number" !== typeof numbers[i]) {
+        throw new Error(`assertNumbers arguments[${i}] is not a number. ${typeof numbers[i]} == typeof ${numbers[i]}`);
+      }
+    }
+  }
+  return true;
+}
+var PI = Math.PI;
+function annotateArcCommand(c, x1, y1) {
+  c.lArcFlag = 0 === c.lArcFlag ? 0 : 1;
+  c.sweepFlag = 0 === c.sweepFlag ? 0 : 1;
+  let { rX, rY } = c;
+  const { x, y } = c;
+  if (Math.abs(rX) < 1e-10 || Math.abs(rY) < 1e-10) {
+    c.rX = 0;
+    c.rY = 0;
+    c.cX = (x1 + x) / 2;
+    c.cY = (y1 + y) / 2;
+    c.phi1 = 0;
+    c.phi2 = 0;
+    return;
+  }
+  rX = Math.abs(c.rX);
+  rY = Math.abs(c.rY);
+  const xRotRad = c.xRot / 180 * PI;
+  const [x1_, y1_] = rotate([(x1 - x) / 2, (y1 - y) / 2], -xRotRad);
+  const testValue = Math.pow(x1_, 2) / Math.pow(rX, 2) + Math.pow(y1_, 2) / Math.pow(rY, 2);
+  if (1 < testValue) {
+    rX *= Math.sqrt(testValue);
+    rY *= Math.sqrt(testValue);
+  }
+  c.rX = rX;
+  c.rY = rY;
+  const c_ScaleTemp = Math.pow(rX, 2) * Math.pow(y1_, 2) + Math.pow(rY, 2) * Math.pow(x1_, 2);
+  const c_Scale = (c.lArcFlag !== c.sweepFlag ? 1 : -1) * Math.sqrt(Math.max(0, (Math.pow(rX, 2) * Math.pow(rY, 2) - c_ScaleTemp) / c_ScaleTemp));
+  const cx_ = rX * y1_ / rY * c_Scale;
+  const cy_ = -rY * x1_ / rX * c_Scale;
+  const cRot = rotate([cx_, cy_], xRotRad);
+  c.cX = cRot[0] + (x1 + x) / 2;
+  c.cY = cRot[1] + (y1 + y) / 2;
+  c.phi1 = Math.atan2((y1_ - cy_) / rY, (x1_ - cx_) / rX);
+  c.phi2 = Math.atan2((-y1_ - cy_) / rY, (-x1_ - cx_) / rX);
+  if (0 === c.sweepFlag && c.phi2 > c.phi1) {
+    c.phi2 -= 2 * PI;
+  }
+  if (1 === c.sweepFlag && c.phi2 < c.phi1) {
+    c.phi2 += 2 * PI;
+  }
+  c.phi1 *= 180 / PI;
+  c.phi2 *= 180 / PI;
+}
+function intersectionUnitCircleLine(a, b, c) {
+  assertNumbers(a, b, c);
+  const termSqr = a * a + b * b - c * c;
+  if (0 > termSqr) {
+    return [];
+  } else if (0 === termSqr) {
+    return [[a * c / (a * a + b * b), b * c / (a * a + b * b)]];
+  }
+  const term = Math.sqrt(termSqr);
+  return [
+    [
+      (a * c + b * term) / (a * a + b * b),
+      (b * c - a * term) / (a * a + b * b)
+    ],
+    [
+      (a * c - b * term) / (a * a + b * b),
+      (b * c + a * term) / (a * a + b * b)
+    ]
+  ];
+}
+var DEG = Math.PI / 180;
+function lerp(a, b, t) {
+  return (1 - t) * a + t * b;
+}
+function arcAt(c, x1, x2, phiDeg) {
+  return c + Math.cos(phiDeg / 180 * PI) * x1 + Math.sin(phiDeg / 180 * PI) * x2;
+}
+function bezierRoot(x0, x1, x2, x3) {
+  const EPS = 1e-6;
+  const x01 = x1 - x0;
+  const x12 = x2 - x1;
+  const x23 = x3 - x2;
+  const a = 3 * x01 + 3 * x23 - 6 * x12;
+  const b = (x12 - x01) * 6;
+  const c = 3 * x01;
+  if (Math.abs(a) < EPS) {
+    return Math.abs(b) < EPS ? [] : [-c / b];
+  }
+  return pqFormula(b / a, c / a, EPS);
+}
+function bezierAt(x0, x1, x2, x3, t) {
+  const s = 1 - t;
+  const c0 = s * s * s;
+  const c1 = 3 * s * s * t;
+  const c2 = 3 * s * t * t;
+  const c3 = t * t * t;
+  return x0 * c0 + x1 * c1 + x2 * c2 + x3 * c3;
+}
+function pqFormula(p, q, PRECISION = 1e-6) {
+  const discriminantX4 = p * p / 4 - q;
+  if (discriminantX4 < -PRECISION) {
+    return [];
+  } else if (discriminantX4 <= PRECISION) {
+    return [-p / 2];
+  }
+  const root = Math.sqrt(discriminantX4);
+  return [-(p / 2) - root, -(p / 2) + root];
+}
+function a2c(arc, x0, y0) {
+  if (!arc.cX) {
+    annotateArcCommand(arc, x0, y0);
+  }
+  const xRotRad = arc.xRot / 180 * PI;
+  if (Math.abs(arc.rX) < 1e-10 || Math.abs(arc.rY) < 1e-10) {
+    return [
+      {
+        relative: arc.relative,
+        type: SVGPathData.CURVE_TO,
+        x1: x0 + (arc.x - x0) / 3,
+        y1: y0 + (arc.y - y0) / 3,
+        x2: x0 + 2 * (arc.x - x0) / 3,
+        y2: y0 + 2 * (arc.y - y0) / 3,
+        x: arc.x,
+        y: arc.y
+      }
+    ];
+  }
+  const phiMin = Math.min(arc.phi1, arc.phi2), phiMax = Math.max(arc.phi1, arc.phi2), deltaPhi = phiMax - phiMin;
+  const partCount = Math.ceil(deltaPhi / 90);
+  const result = new Array(partCount);
+  let prevX = x0;
+  let prevY = y0;
+  const transform = (x, y) => {
+    const [xTemp, yTemp] = rotate([x * arc.rX, y * arc.rY], xRotRad);
+    return [arc.cX + xTemp, arc.cY + yTemp];
+  };
+  for (let i = 0; i < partCount; i++) {
+    const phiStart = lerp(arc.phi1, arc.phi2, i / partCount);
+    const phiEnd = lerp(arc.phi1, arc.phi2, (i + 1) / partCount);
+    const deltaPhi2 = phiEnd - phiStart;
+    const f = 4 / 3 * Math.tan(deltaPhi2 * DEG / 4);
+    const x1 = Math.cos(phiStart * DEG) - f * Math.sin(phiStart * DEG);
+    const y1 = Math.sin(phiStart * DEG) + f * Math.cos(phiStart * DEG);
+    const x = Math.cos(phiEnd * DEG);
+    const y = Math.sin(phiEnd * DEG);
+    const x2 = x + f * y;
+    const y2 = y - f * x;
+    const cp1 = transform(x1, y1);
+    const cp2 = transform(x2, y2);
+    const end = transform(x, y);
+    const command = {
+      relative: arc.relative,
+      type: SVGPathData.CURVE_TO,
+      x: end[0],
+      y: end[1],
+      x1: cp1[0],
+      y1: cp1[1],
+      x2: cp2[0],
+      y2: cp2[1]
+    };
+    if (arc.relative) {
+      command.x1 -= prevX;
+      command.y1 -= prevY;
+      command.x2 -= prevX;
+      command.y2 -= prevY;
+      command.x -= prevX;
+      command.y -= prevY;
+    }
+    prevX = end[0];
+    prevY = end[1];
+    result[i] = command;
+  }
+  return result;
+}
+function arePointsCollinear(p1, p2, p3) {
+  const v1x = p2[0] - p1[0];
+  const v1y = p2[1] - p1[1];
+  const v2x = p3[0] - p1[0];
+  const v2y = p3[1] - p1[1];
+  const cross = v1x * v2y - v1y * v2x;
+  const isCollinear = Math.abs(cross) < 1e-10;
+  if (!isCollinear)
+    return false;
+  const dot = v1x * v2x + v1y * v2y;
+  const lenSqV1 = v1x * v1x + v1y * v1y;
+  const lenSqV2 = v2x * v2x + v2y * v2y;
+  return 0 <= dot && dot <= lenSqV2 && lenSqV1 <= lenSqV2;
+}
+
+// ../../node_modules/svg-pathdata/dist/transformers/reverse_path.js
+function REVERSE_PATH(commands, preserveSubpathOrder = true) {
+  if (commands.length < 2)
+    return commands;
+  const normalized = SVGPathDataTransformer.INFO((command, px, py) => ({
+    ...command,
+    x: command.x ?? px,
+    y: command.y ?? py,
+    relative: command.relative ?? false
+  }));
+  const result = [];
+  let processing = [];
+  for (const original of commands) {
+    const cmd = normalized(original);
+    if (cmd.type === SVGPathData.MOVE_TO && processing.length > 0) {
+      if (preserveSubpathOrder) {
+        result.push(...reverseSubpath(processing));
+      } else {
+        result.unshift(...reverseSubpath(processing));
+      }
+      processing = [];
+    }
+    processing.push(cmd);
+  }
+  if (processing.length > 0) {
+    if (preserveSubpathOrder) {
+      result.push(...reverseSubpath(processing));
+    } else {
+      result.unshift(...reverseSubpath(processing));
+    }
+  }
+  return result;
+}
+function reverseSubpath(commands) {
+  const isExplicitlyClosed = commands[commands.length - 1]?.type === SVGPathData.CLOSE_PATH;
+  const startPointIndex = isExplicitlyClosed ? commands.length - 2 : commands.length - 1;
+  const reversed = [
+    {
+      type: SVGPathData.MOVE_TO,
+      relative: false,
+      x: commands[startPointIndex].x,
+      y: commands[startPointIndex].y
+    }
+  ];
+  for (let i = startPointIndex; i > 0; i--) {
+    const curCmd = commands[i];
+    const prevPoint = commands[i - 1];
+    if (curCmd.relative) {
+      throw new Error("Relative command are not supported convert first with `toAbs()`");
+    }
+    switch (curCmd.type) {
+      case SVGPathData.HORIZ_LINE_TO:
+        reversed.push({
+          type: SVGPathData.HORIZ_LINE_TO,
+          relative: false,
+          x: prevPoint.x
+        });
+        break;
+      case SVGPathData.VERT_LINE_TO:
+        reversed.push({
+          type: SVGPathData.VERT_LINE_TO,
+          relative: false,
+          y: prevPoint.y
+        });
+        break;
+      case SVGPathData.LINE_TO:
+      case SVGPathData.MOVE_TO:
+        reversed.push({
+          type: SVGPathData.LINE_TO,
+          relative: false,
+          x: prevPoint.x,
+          y: prevPoint.y
+        });
+        break;
+      case SVGPathData.CURVE_TO:
+        reversed.push({
+          type: SVGPathData.CURVE_TO,
+          relative: false,
+          x: prevPoint.x,
+          y: prevPoint.y,
+          x1: curCmd.x2,
+          y1: curCmd.y2,
+          x2: curCmd.x1,
+          y2: curCmd.y1
+        });
+        break;
+      case SVGPathData.SMOOTH_CURVE_TO:
+        throw new Error(`Unsupported command: S (smooth cubic bezier)`);
+      case SVGPathData.SMOOTH_QUAD_TO:
+        throw new Error(`Unsupported command: T (smooth quadratic bezier)`);
+      case SVGPathData.ARC:
+        throw new Error(`Unsupported command: A (arc)`);
+      case SVGPathData.QUAD_TO:
+        throw new Error(`Unsupported command: Q (quadratic bezier)`);
+    }
+  }
+  if (isExplicitlyClosed) {
+    reversed.push({ type: SVGPathData.CLOSE_PATH });
+  }
+  return reversed;
+}
+
+// ../../node_modules/svg-pathdata/dist/SVGPathDataTransformer.js
+function ROUND(roundVal = 1e13) {
+  assertNumbers(roundVal);
+  function rf(val) {
+    return Math.round(val * roundVal) / roundVal;
+  }
+  return function round(command) {
+    if ("x1" in command && "undefined" !== typeof command.x1) {
+      command.x1 = rf(command.x1);
+    }
+    if ("y1" in command && "undefined" !== typeof command.y1) {
+      command.y1 = rf(command.y1);
+    }
+    if ("x2" in command && "undefined" !== typeof command.x2) {
+      command.x2 = rf(command.x2);
+    }
+    if ("y2" in command && "undefined" !== typeof command.y2) {
+      command.y2 = rf(command.y2);
+    }
+    if ("x" in command && "undefined" !== typeof command.x) {
+      command.x = rf(command.x);
+    }
+    if ("y" in command && "undefined" !== typeof command.y) {
+      command.y = rf(command.y);
+    }
+    if ("rX" in command && "undefined" !== typeof command.rX) {
+      command.rX = rf(command.rX);
+    }
+    if ("rY" in command && "undefined" !== typeof command.rY) {
+      command.rY = rf(command.rY);
+    }
+    return command;
+  };
+}
+function TO_ABS() {
+  return INFO((command, prevX, prevY) => {
+    if (command.relative) {
+      if ("undefined" !== typeof command.x1) {
+        command.x1 += prevX;
+      }
+      if ("undefined" !== typeof command.y1) {
+        command.y1 += prevY;
+      }
+      if ("undefined" !== typeof command.x2) {
+        command.x2 += prevX;
+      }
+      if ("undefined" !== typeof command.y2) {
+        command.y2 += prevY;
+      }
+      if ("undefined" !== typeof command.x) {
+        command.x += prevX;
+      }
+      if ("undefined" !== typeof command.y) {
+        command.y += prevY;
+      }
+      command.relative = false;
+    }
+    return command;
+  });
+}
+function TO_REL() {
+  return INFO((command, prevX, prevY) => {
+    if (!command.relative) {
+      if ("undefined" !== typeof command.x1) {
+        command.x1 -= prevX;
+      }
+      if ("undefined" !== typeof command.y1) {
+        command.y1 -= prevY;
+      }
+      if ("undefined" !== typeof command.x2) {
+        command.x2 -= prevX;
+      }
+      if ("undefined" !== typeof command.y2) {
+        command.y2 -= prevY;
+      }
+      if ("undefined" !== typeof command.x) {
+        command.x -= prevX;
+      }
+      if ("undefined" !== typeof command.y) {
+        command.y -= prevY;
+      }
+      command.relative = true;
+    }
+    return command;
+  });
+}
+function NORMALIZE_HVZ(normalizeZ = true, normalizeH = true, normalizeV = true, normalizeC = true) {
+  return INFO((command, prevX, prevY, pathStartX, pathStartY) => {
+    if (isNaN(pathStartX) && !(command.type & SVGPathData.MOVE_TO)) {
+      throw new Error("path must start with moveto");
+    }
+    if (normalizeH && command.type & SVGPathData.HORIZ_LINE_TO) {
+      command.type = SVGPathData.LINE_TO;
+      command.y = command.relative ? 0 : prevY;
+    }
+    if (normalizeV && command.type & SVGPathData.VERT_LINE_TO) {
+      command.type = SVGPathData.LINE_TO;
+      command.x = command.relative ? 0 : prevX;
+    }
+    if (normalizeZ && command.type & SVGPathData.CLOSE_PATH) {
+      command.type = SVGPathData.LINE_TO;
+      command.x = command.relative ? pathStartX - prevX : pathStartX;
+      command.y = command.relative ? pathStartY - prevY : pathStartY;
+    }
+    if (command.type & SVGPathData.ARC && (0 === command.rX || 0 === command.rY)) {
+      command.type = SVGPathData.LINE_TO;
+      delete command.rX;
+      delete command.rY;
+      delete command.xRot;
+      delete command.lArcFlag;
+      delete command.sweepFlag;
+    }
+    if (normalizeC && command.type & SVGPathData.QUAD_TO) {
+      const startPoint = [prevX, prevY];
+      const controlPoint = command.relative ? [prevX + command.x1, prevY + command.y1] : [command.x1, command.y1];
+      const endPoint = command.relative ? [prevX + command.x, prevY + command.y] : [command.x, command.y];
+      if (arePointsCollinear(startPoint, controlPoint, endPoint)) {
+        command.type = SVGPathData.LINE_TO;
+        delete command.x1;
+        delete command.y1;
+      }
+    }
+    if (normalizeC && command.type & SVGPathData.CURVE_TO) {
+      const startPoint = [prevX, prevY];
+      const control1 = command.relative ? [prevX + command.x1, prevY + command.y1] : [command.x1, command.y1];
+      const control2 = command.relative ? [prevX + command.x2, prevY + command.y2] : [command.x2, command.y2];
+      const endPoint = command.relative ? [prevX + command.x, prevY + command.y] : [command.x, command.y];
+      if (arePointsCollinear(startPoint, control1, endPoint) && arePointsCollinear(startPoint, control2, endPoint)) {
+        command.type = SVGPathData.LINE_TO;
+        delete command.x1;
+        delete command.y1;
+        delete command.x2;
+        delete command.y2;
+      }
+    }
+    return command;
+  });
+}
+function NORMALIZE_ST() {
+  let prevCurveC2X = NaN;
+  let prevCurveC2Y = NaN;
+  let prevQuadCX = NaN;
+  let prevQuadCY = NaN;
+  return INFO((command, prevX, prevY) => {
+    if (command.type & SVGPathData.SMOOTH_CURVE_TO) {
+      command.type = SVGPathData.CURVE_TO;
+      prevCurveC2X = isNaN(prevCurveC2X) ? prevX : prevCurveC2X;
+      prevCurveC2Y = isNaN(prevCurveC2Y) ? prevY : prevCurveC2Y;
+      command.x1 = command.relative ? prevX - prevCurveC2X : 2 * prevX - prevCurveC2X;
+      command.y1 = command.relative ? prevY - prevCurveC2Y : 2 * prevY - prevCurveC2Y;
+    }
+    if (command.type & SVGPathData.CURVE_TO) {
+      prevCurveC2X = command.relative ? prevX + command.x2 : command.x2;
+      prevCurveC2Y = command.relative ? prevY + command.y2 : command.y2;
+    } else {
+      prevCurveC2X = NaN;
+      prevCurveC2Y = NaN;
+    }
+    if (command.type & SVGPathData.SMOOTH_QUAD_TO) {
+      command.type = SVGPathData.QUAD_TO;
+      prevQuadCX = isNaN(prevQuadCX) ? prevX : prevQuadCX;
+      prevQuadCY = isNaN(prevQuadCY) ? prevY : prevQuadCY;
+      command.x1 = command.relative ? prevX - prevQuadCX : 2 * prevX - prevQuadCX;
+      command.y1 = command.relative ? prevY - prevQuadCY : 2 * prevY - prevQuadCY;
+    }
+    if (command.type & SVGPathData.QUAD_TO) {
+      prevQuadCX = command.relative ? prevX + command.x1 : command.x1;
+      prevQuadCY = command.relative ? prevY + command.y1 : command.y1;
+    } else {
+      prevQuadCX = NaN;
+      prevQuadCY = NaN;
+    }
+    return command;
+  });
+}
+function QT_TO_C() {
+  let prevQuadX1 = NaN;
+  let prevQuadY1 = NaN;
+  return INFO((command, prevX, prevY) => {
+    if (command.type & SVGPathData.SMOOTH_QUAD_TO) {
+      command.type = SVGPathData.QUAD_TO;
+      prevQuadX1 = isNaN(prevQuadX1) ? prevX : prevQuadX1;
+      prevQuadY1 = isNaN(prevQuadY1) ? prevY : prevQuadY1;
+      command.x1 = command.relative ? prevX - prevQuadX1 : 2 * prevX - prevQuadX1;
+      command.y1 = command.relative ? prevY - prevQuadY1 : 2 * prevY - prevQuadY1;
+    }
+    if (command.type & SVGPathData.QUAD_TO) {
+      prevQuadX1 = command.relative ? prevX + command.x1 : command.x1;
+      prevQuadY1 = command.relative ? prevY + command.y1 : command.y1;
+      const x1 = command.x1;
+      const y1 = command.y1;
+      command.type = SVGPathData.CURVE_TO;
+      command.x1 = ((command.relative ? 0 : prevX) + x1 * 2) / 3;
+      command.y1 = ((command.relative ? 0 : prevY) + y1 * 2) / 3;
+      command.x2 = (command.x + x1 * 2) / 3;
+      command.y2 = (command.y + y1 * 2) / 3;
+    } else {
+      prevQuadX1 = NaN;
+      prevQuadY1 = NaN;
+    }
+    return command;
+  });
+}
+function INFO(f) {
+  let prevXAbs = 0;
+  let prevYAbs = 0;
+  let pathStartXAbs = NaN;
+  let pathStartYAbs = NaN;
+  return function transform(command) {
+    if (isNaN(pathStartXAbs) && !(command.type & SVGPathData.MOVE_TO)) {
+      throw new Error("path must start with moveto");
+    }
+    const result = f(command, prevXAbs, prevYAbs, pathStartXAbs, pathStartYAbs);
+    if (command.type & SVGPathData.CLOSE_PATH) {
+      prevXAbs = pathStartXAbs;
+      prevYAbs = pathStartYAbs;
+    }
+    if ("x" in command && "undefined" !== typeof command.x) {
+      prevXAbs = command.relative ? prevXAbs + command.x : command.x;
+    }
+    if ("y" in command && "undefined" !== typeof command.y) {
+      prevYAbs = command.relative ? prevYAbs + command.y : command.y;
+    }
+    if (command.type & SVGPathData.MOVE_TO) {
+      pathStartXAbs = prevXAbs;
+      pathStartYAbs = prevYAbs;
+    }
+    return result;
+  };
+}
+function SANITIZE(EPS = 0) {
+  assertNumbers(EPS);
+  let prevCurveC2X = NaN;
+  let prevCurveC2Y = NaN;
+  let prevQuadCX = NaN;
+  let prevQuadCY = NaN;
+  return INFO((command, prevX, prevY, pathStartX, pathStartY) => {
+    const abs = Math.abs;
+    let skip = false;
+    let x1Rel = 0;
+    let y1Rel = 0;
+    if (command.type & SVGPathData.SMOOTH_CURVE_TO) {
+      x1Rel = isNaN(prevCurveC2X) ? 0 : prevX - prevCurveC2X;
+      y1Rel = isNaN(prevCurveC2Y) ? 0 : prevY - prevCurveC2Y;
+    }
+    if (command.type & (SVGPathData.CURVE_TO | SVGPathData.SMOOTH_CURVE_TO)) {
+      prevCurveC2X = command.relative ? prevX + command.x2 : command.x2;
+      prevCurveC2Y = command.relative ? prevY + command.y2 : command.y2;
+    } else {
+      prevCurveC2X = NaN;
+      prevCurveC2Y = NaN;
+    }
+    if (command.type & SVGPathData.SMOOTH_QUAD_TO) {
+      prevQuadCX = isNaN(prevQuadCX) ? prevX : 2 * prevX - prevQuadCX;
+      prevQuadCY = isNaN(prevQuadCY) ? prevY : 2 * prevY - prevQuadCY;
+    } else if (command.type & SVGPathData.QUAD_TO) {
+      prevQuadCX = command.relative ? prevX + command.x1 : command.x1;
+      prevQuadCY = command.relative ? prevY + command.y1 : command.y2;
+    } else {
+      prevQuadCX = NaN;
+      prevQuadCY = NaN;
+    }
+    if (command.type & SVGPathData.LINE_COMMANDS || command.type & SVGPathData.ARC && (0 === command.rX || 0 === command.rY || !command.lArcFlag) || command.type & SVGPathData.CURVE_TO || command.type & SVGPathData.SMOOTH_CURVE_TO || command.type & SVGPathData.QUAD_TO || command.type & SVGPathData.SMOOTH_QUAD_TO) {
+      const xRel = "undefined" === typeof command.x ? 0 : command.relative ? command.x : command.x - prevX;
+      const yRel = "undefined" === typeof command.y ? 0 : command.relative ? command.y : command.y - prevY;
+      x1Rel = !isNaN(prevQuadCX) ? prevQuadCX - prevX : "undefined" === typeof command.x1 ? x1Rel : command.relative ? command.x : command.x1 - prevX;
+      y1Rel = !isNaN(prevQuadCY) ? prevQuadCY - prevY : "undefined" === typeof command.y1 ? y1Rel : command.relative ? command.y : command.y1 - prevY;
+      const x2Rel = "undefined" === typeof command.x2 ? 0 : command.relative ? command.x : command.x2 - prevX;
+      const y2Rel = "undefined" === typeof command.y2 ? 0 : command.relative ? command.y : command.y2 - prevY;
+      if (abs(xRel) <= EPS && abs(yRel) <= EPS && abs(x1Rel) <= EPS && abs(y1Rel) <= EPS && abs(x2Rel) <= EPS && abs(y2Rel) <= EPS) {
+        skip = true;
+      }
+    }
+    if (command.type & SVGPathData.CLOSE_PATH) {
+      if (abs(prevX - pathStartX) <= EPS && abs(prevY - pathStartY) <= EPS) {
+        skip = true;
+      }
+    }
+    return skip ? [] : command;
+  });
+}
+function MATRIX(a, b, c, d, e, f) {
+  assertNumbers(a, b, c, d, e, f);
+  return INFO((command, prevX, prevY, pathStartX) => {
+    const origX1 = command.x1;
+    const origX2 = command.x2;
+    const comRel = command.relative && !isNaN(pathStartX);
+    const x = "undefined" !== typeof command.x ? command.x : comRel ? 0 : prevX;
+    const y = "undefined" !== typeof command.y ? command.y : comRel ? 0 : prevY;
+    if (command.type & SVGPathData.HORIZ_LINE_TO && 0 !== b) {
+      command.type = SVGPathData.LINE_TO;
+      command.y = command.relative ? 0 : prevY;
+    }
+    if (command.type & SVGPathData.VERT_LINE_TO && 0 !== c) {
+      command.type = SVGPathData.LINE_TO;
+      command.x = command.relative ? 0 : prevX;
+    }
+    if ("undefined" !== typeof command.x) {
+      command.x = command.x * a + y * c + (comRel ? 0 : e);
+    }
+    if ("undefined" !== typeof command.y) {
+      command.y = x * b + command.y * d + (comRel ? 0 : f);
+    }
+    if ("undefined" !== typeof command.x1) {
+      command.x1 = command.x1 * a + command.y1 * c + (comRel ? 0 : e);
+    }
+    if ("undefined" !== typeof command.y1) {
+      command.y1 = origX1 * b + command.y1 * d + (comRel ? 0 : f);
+    }
+    if ("undefined" !== typeof command.x2) {
+      command.x2 = command.x2 * a + command.y2 * c + (comRel ? 0 : e);
+    }
+    if ("undefined" !== typeof command.y2) {
+      command.y2 = origX2 * b + command.y2 * d + (comRel ? 0 : f);
+    }
+    function sqr(x2) {
+      return x2 * x2;
+    }
+    const det = a * d - b * c;
+    if ("undefined" !== typeof command.xRot) {
+      if (1 !== a || 0 !== b || 0 !== c || 1 !== d) {
+        if (0 === det) {
+          delete command.rX;
+          delete command.rY;
+          delete command.xRot;
+          delete command.lArcFlag;
+          delete command.sweepFlag;
+          command.type = SVGPathData.LINE_TO;
+        } else {
+          const xRot = command.xRot * Math.PI / 180;
+          const sinRot = Math.sin(xRot);
+          const cosRot = Math.cos(xRot);
+          const xCurve = 1 / sqr(command.rX);
+          const yCurve = 1 / sqr(command.rY);
+          const A = sqr(cosRot) * xCurve + sqr(sinRot) * yCurve;
+          const B = 2 * sinRot * cosRot * (xCurve - yCurve);
+          const C = sqr(sinRot) * xCurve + sqr(cosRot) * yCurve;
+          const A1 = A * d * d - B * b * d + C * b * b;
+          const B1 = B * (a * d + b * c) - 2 * (A * c * d + C * a * b);
+          const C1 = A * c * c - B * a * c + C * a * a;
+          const newXRot = (Math.atan2(B1, A1 - C1) + Math.PI) % Math.PI / 2;
+          const newSinRot = Math.sin(newXRot);
+          const newCosRot = Math.cos(newXRot);
+          command.rX = Math.abs(det) / Math.sqrt(A1 * sqr(newCosRot) + B1 * newSinRot * newCosRot + C1 * sqr(newSinRot));
+          command.rY = Math.abs(det) / Math.sqrt(A1 * sqr(newSinRot) - B1 * newSinRot * newCosRot + C1 * sqr(newCosRot));
+          command.xRot = newXRot * 180 / Math.PI;
+        }
+      }
+    }
+    if ("undefined" !== typeof command.sweepFlag && 0 > det) {
+      command.sweepFlag = +!command.sweepFlag;
+    }
+    return command;
+  });
+}
+function ROTATE(a, x = 0, y = 0) {
+  assertNumbers(a, x, y);
+  const sin = Math.sin(a);
+  const cos = Math.cos(a);
+  return MATRIX(cos, sin, -sin, cos, x - x * cos + y * sin, y - x * sin - y * cos);
+}
+function TRANSLATE(dX, dY = 0) {
+  assertNumbers(dX, dY);
+  return MATRIX(1, 0, 0, 1, dX, dY);
+}
+function SCALE(dX, dY = dX) {
+  assertNumbers(dX, dY);
+  return MATRIX(dX, 0, 0, dY, 0, 0);
+}
+function SKEW_X(a) {
+  assertNumbers(a);
+  return MATRIX(1, 0, Math.tan(a), 1, 0, 0);
+}
+function SKEW_Y(a) {
+  assertNumbers(a);
+  return MATRIX(1, Math.tan(a), 0, 1, 0, 0);
+}
+function X_AXIS_SYMMETRY(xOffset = 0) {
+  assertNumbers(xOffset);
+  return MATRIX(-1, 0, 0, 1, xOffset, 0);
+}
+function Y_AXIS_SYMMETRY(yOffset = 0) {
+  assertNumbers(yOffset);
+  return MATRIX(1, 0, 0, -1, 0, yOffset);
+}
+function A_TO_C() {
+  return INFO((command, prevX, prevY) => {
+    if (SVGPathData.ARC === command.type) {
+      return a2c(command, command.relative ? 0 : prevX, command.relative ? 0 : prevY);
+    }
+    return command;
+  });
+}
+function ANNOTATE_ARCS() {
+  return INFO((c, x1, y1) => {
+    if (c.relative) {
+      x1 = 0;
+      y1 = 0;
+    }
+    if (SVGPathData.ARC === c.type) {
+      annotateArcCommand(c, x1, y1);
+    }
+    return c;
+  });
+}
+function CLONE() {
+  return (c) => {
+    return { ...c };
+  };
+}
+function CALCULATE_BOUNDS() {
+  const clone = CLONE();
+  const toAbs = TO_ABS();
+  const qtToC = QT_TO_C();
+  const normST = NORMALIZE_ST();
+  const f = INFO((command, prevXAbs, prevYAbs) => {
+    const c = normST(qtToC(toAbs(clone(command))));
+    function fixX(absX) {
+      if (absX > f.maxX) {
+        f.maxX = absX;
+      }
+      if (absX < f.minX) {
+        f.minX = absX;
+      }
+    }
+    function fixY(absY) {
+      if (absY > f.maxY) {
+        f.maxY = absY;
+      }
+      if (absY < f.minY) {
+        f.minY = absY;
+      }
+    }
+    if (c.type & SVGPathData.DRAWING_COMMANDS) {
+      fixX(prevXAbs);
+      fixY(prevYAbs);
+    }
+    if (c.type & SVGPathData.HORIZ_LINE_TO) {
+      fixX(c.x);
+    }
+    if (c.type & SVGPathData.VERT_LINE_TO) {
+      fixY(c.y);
+    }
+    if (c.type & SVGPathData.LINE_TO) {
+      fixX(c.x);
+      fixY(c.y);
+    }
+    if (c.type & SVGPathData.CURVE_TO) {
+      fixX(c.x);
+      fixY(c.y);
+      const xDerivRoots = bezierRoot(prevXAbs, c.x1, c.x2, c.x);
+      for (const derivRoot of xDerivRoots) {
+        if (0 < derivRoot && 1 > derivRoot) {
+          fixX(bezierAt(prevXAbs, c.x1, c.x2, c.x, derivRoot));
+        }
+      }
+      const yDerivRoots = bezierRoot(prevYAbs, c.y1, c.y2, c.y);
+      for (const derivRoot of yDerivRoots) {
+        if (0 < derivRoot && 1 > derivRoot) {
+          fixY(bezierAt(prevYAbs, c.y1, c.y2, c.y, derivRoot));
+        }
+      }
+    }
+    if (c.type & SVGPathData.ARC) {
+      fixX(c.x);
+      fixY(c.y);
+      annotateArcCommand(c, prevXAbs, prevYAbs);
+      const xRotRad = c.xRot / 180 * Math.PI;
+      const x0 = Math.cos(xRotRad) * c.rX;
+      const y0 = Math.sin(xRotRad) * c.rX;
+      const x90 = -Math.sin(xRotRad) * c.rY;
+      const y90 = Math.cos(xRotRad) * c.rY;
+      const [phiMin, phiMax] = c.phi1 < c.phi2 ? [c.phi1, c.phi2] : -180 > c.phi2 ? [c.phi2 + 360, c.phi1 + 360] : [c.phi2, c.phi1];
+      const normalizeXiEta = ([xi, eta]) => {
+        const phiRad = Math.atan2(eta, xi);
+        const phi = phiRad * 180 / Math.PI;
+        return phi < phiMin ? phi + 360 : phi;
+      };
+      const xDerivRoots = intersectionUnitCircleLine(x90, -x0, 0).map(normalizeXiEta);
+      for (const derivRoot of xDerivRoots) {
+        if (derivRoot > phiMin && derivRoot < phiMax) {
+          fixX(arcAt(c.cX, x0, x90, derivRoot));
+        }
+      }
+      const yDerivRoots = intersectionUnitCircleLine(y90, -y0, 0).map(normalizeXiEta);
+      for (const derivRoot of yDerivRoots) {
+        if (derivRoot > phiMin && derivRoot < phiMax) {
+          fixY(arcAt(c.cY, y0, y90, derivRoot));
+        }
+      }
+    }
+    return command;
+  });
+  f.minX = Infinity;
+  f.maxX = -Infinity;
+  f.minY = Infinity;
+  f.maxY = -Infinity;
+  return f;
+}
+var SVGPathDataTransformer = {
+  ROUND,
+  TO_ABS,
+  TO_REL,
+  NORMALIZE_HVZ,
+  NORMALIZE_ST,
+  QT_TO_C,
+  INFO,
+  SANITIZE,
+  MATRIX,
+  ROTATE,
+  TRANSLATE,
+  SCALE,
+  SKEW_X,
+  SKEW_Y,
+  X_AXIS_SYMMETRY,
+  Y_AXIS_SYMMETRY,
+  A_TO_C,
+  ANNOTATE_ARCS,
+  CLONE,
+  CALCULATE_BOUNDS,
+  REVERSE_PATH
+};
+
+// ../../node_modules/svg-pathdata/dist/TransformableSVG.js
+var TransformableSVG = class {
+  round(x) {
+    return this.transform(SVGPathDataTransformer.ROUND(x));
+  }
+  toAbs() {
+    return this.transform(SVGPathDataTransformer.TO_ABS());
+  }
+  toRel() {
+    return this.transform(SVGPathDataTransformer.TO_REL());
+  }
+  normalizeHVZ(a, b, c) {
+    return this.transform(SVGPathDataTransformer.NORMALIZE_HVZ(a, b, c));
+  }
+  normalizeST() {
+    return this.transform(SVGPathDataTransformer.NORMALIZE_ST());
+  }
+  qtToC() {
+    return this.transform(SVGPathDataTransformer.QT_TO_C());
+  }
+  aToC() {
+    return this.transform(SVGPathDataTransformer.A_TO_C());
+  }
+  sanitize(eps) {
+    return this.transform(SVGPathDataTransformer.SANITIZE(eps));
+  }
+  translate(x, y) {
+    return this.transform(SVGPathDataTransformer.TRANSLATE(x, y));
+  }
+  scale(x, y) {
+    return this.transform(SVGPathDataTransformer.SCALE(x, y));
+  }
+  rotate(a, x, y) {
+    return this.transform(SVGPathDataTransformer.ROTATE(a, x, y));
+  }
+  matrix(a, b, c, d, e, f) {
+    return this.transform(SVGPathDataTransformer.MATRIX(a, b, c, d, e, f));
+  }
+  skewX(a) {
+    return this.transform(SVGPathDataTransformer.SKEW_X(a));
+  }
+  skewY(a) {
+    return this.transform(SVGPathDataTransformer.SKEW_Y(a));
+  }
+  xSymmetry(xOffset) {
+    return this.transform(SVGPathDataTransformer.X_AXIS_SYMMETRY(xOffset));
+  }
+  ySymmetry(yOffset) {
+    return this.transform(SVGPathDataTransformer.Y_AXIS_SYMMETRY(yOffset));
+  }
+  annotateArcs() {
+    return this.transform(SVGPathDataTransformer.ANNOTATE_ARCS());
+  }
+};
+
+// ../../node_modules/svg-pathdata/dist/SVGPathDataParser.js
+var isWhiteSpace = (c) => " " === c || "	" === c || "\r" === c || "\n" === c;
+var isDigit = (c) => "0".charCodeAt(0) <= c.charCodeAt(0) && c.charCodeAt(0) <= "9".charCodeAt(0);
+var SVGPathDataParser = class extends TransformableSVG {
+  curNumber = "";
+  curCommandType = -1;
+  curCommandRelative = false;
+  canParseCommandOrComma = true;
+  curNumberHasExp = false;
+  curNumberHasExpDigits = false;
+  curNumberHasDecimal = false;
+  curArgs = [];
+  constructor() {
+    super();
+  }
+  finish(commands = []) {
+    this.parse(" ", commands);
+    if (0 !== this.curArgs.length || !this.canParseCommandOrComma) {
+      throw new SyntaxError("Unterminated command at the path end.");
+    }
+    return commands;
+  }
+  parse(str, commands = []) {
+    const finishCommand = (command) => {
+      commands.push(command);
+      this.curArgs.length = 0;
+      this.canParseCommandOrComma = true;
+    };
+    for (let i = 0; i < str.length; i++) {
+      const c = str[i];
+      const isAArcFlag = this.curCommandType === SVGPathData.ARC && (this.curArgs.length === 3 || this.curArgs.length === 4) && this.curNumber.length === 1 && (this.curNumber === "0" || this.curNumber === "1");
+      const isEndingDigit = isDigit(c) && (this.curNumber === "0" && c === "0" || isAArcFlag);
+      if (isDigit(c) && !isEndingDigit) {
+        this.curNumber += c;
+        this.curNumberHasExpDigits = this.curNumberHasExp;
+        continue;
+      }
+      if ("e" === c || "E" === c) {
+        this.curNumber += c;
+        this.curNumberHasExp = true;
+        continue;
+      }
+      if (("-" === c || "+" === c) && this.curNumberHasExp && !this.curNumberHasExpDigits) {
+        this.curNumber += c;
+        continue;
+      }
+      if ("." === c && !this.curNumberHasExp && !this.curNumberHasDecimal && !isAArcFlag) {
+        this.curNumber += c;
+        this.curNumberHasDecimal = true;
+        continue;
+      }
+      if (this.curNumber && -1 !== this.curCommandType) {
+        const val = Number(this.curNumber);
+        if (isNaN(val)) {
+          throw new SyntaxError(`Invalid number ending at ${i}`);
+        }
+        if (this.curCommandType === SVGPathData.ARC) {
+          if (0 === this.curArgs.length || 1 === this.curArgs.length) {
+            if (0 > val) {
+              throw new SyntaxError(`Expected positive number, got "${val}" at index "${i}"`);
+            }
+          } else if (3 === this.curArgs.length || 4 === this.curArgs.length) {
+            if ("0" !== this.curNumber && "1" !== this.curNumber) {
+              throw new SyntaxError(`Expected a flag, got "${this.curNumber}" at index "${i}"`);
+            }
+          }
+        }
+        this.curArgs.push(val);
+        if (this.curArgs.length === COMMAND_ARG_COUNTS[this.curCommandType]) {
+          if (SVGPathData.HORIZ_LINE_TO === this.curCommandType) {
+            finishCommand({
+              type: SVGPathData.HORIZ_LINE_TO,
+              relative: this.curCommandRelative,
+              x: val
+            });
+          } else if (SVGPathData.VERT_LINE_TO === this.curCommandType) {
+            finishCommand({
+              type: SVGPathData.VERT_LINE_TO,
+              relative: this.curCommandRelative,
+              y: val
+            });
+          } else if (this.curCommandType === SVGPathData.MOVE_TO || this.curCommandType === SVGPathData.LINE_TO || this.curCommandType === SVGPathData.SMOOTH_QUAD_TO) {
+            finishCommand({
+              type: this.curCommandType,
+              relative: this.curCommandRelative,
+              x: this.curArgs[0],
+              y: this.curArgs[1]
+            });
+            if (SVGPathData.MOVE_TO === this.curCommandType) {
+              this.curCommandType = SVGPathData.LINE_TO;
+            }
+          } else if (this.curCommandType === SVGPathData.CURVE_TO) {
+            finishCommand({
+              type: SVGPathData.CURVE_TO,
+              relative: this.curCommandRelative,
+              x1: this.curArgs[0],
+              y1: this.curArgs[1],
+              x2: this.curArgs[2],
+              y2: this.curArgs[3],
+              x: this.curArgs[4],
+              y: this.curArgs[5]
+            });
+          } else if (this.curCommandType === SVGPathData.SMOOTH_CURVE_TO) {
+            finishCommand({
+              type: SVGPathData.SMOOTH_CURVE_TO,
+              relative: this.curCommandRelative,
+              x2: this.curArgs[0],
+              y2: this.curArgs[1],
+              x: this.curArgs[2],
+              y: this.curArgs[3]
+            });
+          } else if (this.curCommandType === SVGPathData.QUAD_TO) {
+            finishCommand({
+              type: SVGPathData.QUAD_TO,
+              relative: this.curCommandRelative,
+              x1: this.curArgs[0],
+              y1: this.curArgs[1],
+              x: this.curArgs[2],
+              y: this.curArgs[3]
+            });
+          } else if (this.curCommandType === SVGPathData.ARC) {
+            finishCommand({
+              type: SVGPathData.ARC,
+              relative: this.curCommandRelative,
+              rX: this.curArgs[0],
+              rY: this.curArgs[1],
+              xRot: this.curArgs[2],
+              lArcFlag: this.curArgs[3],
+              sweepFlag: this.curArgs[4],
+              x: this.curArgs[5],
+              y: this.curArgs[6]
+            });
+          }
+        }
+        this.curNumber = "";
+        this.curNumberHasExpDigits = false;
+        this.curNumberHasExp = false;
+        this.curNumberHasDecimal = false;
+        this.canParseCommandOrComma = true;
+      }
+      if (isWhiteSpace(c)) {
+        continue;
+      }
+      if ("," === c && this.canParseCommandOrComma) {
+        this.canParseCommandOrComma = false;
+        continue;
+      }
+      if ("+" === c || "-" === c || "." === c) {
+        this.curNumber = c;
+        this.curNumberHasDecimal = "." === c;
+        continue;
+      }
+      if (isEndingDigit) {
+        this.curNumber = c;
+        this.curNumberHasDecimal = false;
+        continue;
+      }
+      if (0 !== this.curArgs.length) {
+        throw new SyntaxError(`Unterminated command at index ${i}.`);
+      }
+      if (!this.canParseCommandOrComma) {
+        throw new SyntaxError(`Unexpected character "${c}" at index ${i}. Command cannot follow comma`);
+      }
+      this.canParseCommandOrComma = false;
+      if ("z" === c || "Z" === c) {
+        commands.push({
+          type: SVGPathData.CLOSE_PATH
+        });
+        this.canParseCommandOrComma = true;
+        this.curCommandType = -1;
+        continue;
+      } else if ("h" === c || "H" === c) {
+        this.curCommandType = SVGPathData.HORIZ_LINE_TO;
+        this.curCommandRelative = "h" === c;
+      } else if ("v" === c || "V" === c) {
+        this.curCommandType = SVGPathData.VERT_LINE_TO;
+        this.curCommandRelative = "v" === c;
+      } else if ("m" === c || "M" === c) {
+        this.curCommandType = SVGPathData.MOVE_TO;
+        this.curCommandRelative = "m" === c;
+      } else if ("l" === c || "L" === c) {
+        this.curCommandType = SVGPathData.LINE_TO;
+        this.curCommandRelative = "l" === c;
+      } else if ("c" === c || "C" === c) {
+        this.curCommandType = SVGPathData.CURVE_TO;
+        this.curCommandRelative = "c" === c;
+      } else if ("s" === c || "S" === c) {
+        this.curCommandType = SVGPathData.SMOOTH_CURVE_TO;
+        this.curCommandRelative = "s" === c;
+      } else if ("q" === c || "Q" === c) {
+        this.curCommandType = SVGPathData.QUAD_TO;
+        this.curCommandRelative = "q" === c;
+      } else if ("t" === c || "T" === c) {
+        this.curCommandType = SVGPathData.SMOOTH_QUAD_TO;
+        this.curCommandRelative = "t" === c;
+      } else if ("a" === c || "A" === c) {
+        this.curCommandType = SVGPathData.ARC;
+        this.curCommandRelative = "a" === c;
+      } else {
+        throw new SyntaxError(`Unexpected character "${c}" at index ${i}.`);
+      }
+    }
+    return commands;
+  }
+  /**
+   * Return a wrapper around this parser which applies the transformation on parsed commands.
+   */
+  transform(transform) {
+    const result = Object.create(this, {
+      parse: {
+        value(chunk, commands = []) {
+          const parsedCommands = Object.getPrototypeOf(this).parse.call(this, chunk);
+          for (const c of parsedCommands) {
+            const cT = transform(c);
+            if (Array.isArray(cT)) {
+              commands.push(...cT);
+            } else {
+              commands.push(cT);
+            }
+          }
+          return commands;
+        }
+      }
+    });
+    return result;
+  }
+};
+
+// ../../node_modules/svg-pathdata/dist/SVGPathData.js
+var SVGPathData = class _SVGPathData extends TransformableSVG {
+  commands;
+  constructor(content) {
+    super();
+    if ("string" === typeof content) {
+      this.commands = _SVGPathData.parse(content);
+    } else {
+      this.commands = content;
+    }
+  }
+  encode() {
+    return _SVGPathData.encode(this.commands);
+  }
+  getBounds() {
+    const boundsTransform = SVGPathDataTransformer.CALCULATE_BOUNDS();
+    this.transform(boundsTransform);
+    return boundsTransform;
+  }
+  transform(transformFunction) {
+    const newCommands = [];
+    for (const command of this.commands) {
+      const transformedCommand = transformFunction(command);
+      if (Array.isArray(transformedCommand)) {
+        newCommands.push(...transformedCommand);
+      } else {
+        newCommands.push(transformedCommand);
+      }
+    }
+    this.commands = newCommands;
+    return this;
+  }
+  /**
+   * Reverses the order of path commands to go from end to start
+   * IMPORTANT: This function expects absolute commands as input.
+   * @param preserveSubpathOrder If true, keeps subpaths in their original order
+   */
+  reverse(preserveSubpathOrder = true) {
+    this.commands = SVGPathDataTransformer.REVERSE_PATH(this.commands, preserveSubpathOrder);
+    return this;
+  }
+  static encode(commands) {
+    return encodeSVGPath(commands);
+  }
+  static parse(path) {
+    const parser = new SVGPathDataParser();
+    const commands = [];
+    parser.parse(path, commands);
+    parser.finish(commands);
+    return commands;
+  }
+  static CLOSE_PATH = 1;
+  static MOVE_TO = 2;
+  static HORIZ_LINE_TO = 4;
+  static VERT_LINE_TO = 8;
+  static LINE_TO = 16;
+  static CURVE_TO = 32;
+  static SMOOTH_CURVE_TO = 64;
+  static QUAD_TO = 128;
+  static SMOOTH_QUAD_TO = 256;
+  static ARC = 512;
+  static LINE_COMMANDS = _SVGPathData.LINE_TO | _SVGPathData.HORIZ_LINE_TO | _SVGPathData.VERT_LINE_TO;
+  static DRAWING_COMMANDS = _SVGPathData.HORIZ_LINE_TO | _SVGPathData.VERT_LINE_TO | _SVGPathData.LINE_TO | _SVGPathData.CURVE_TO | _SVGPathData.SMOOTH_CURVE_TO | _SVGPathData.QUAD_TO | _SVGPathData.SMOOTH_QUAD_TO | _SVGPathData.ARC;
+};
+var COMMAND_ARG_COUNTS = {
+  [SVGPathData.MOVE_TO]: 2,
+  [SVGPathData.LINE_TO]: 2,
+  [SVGPathData.HORIZ_LINE_TO]: 1,
+  [SVGPathData.VERT_LINE_TO]: 1,
+  [SVGPathData.CLOSE_PATH]: 0,
+  [SVGPathData.QUAD_TO]: 4,
+  [SVGPathData.SMOOTH_QUAD_TO]: 2,
+  [SVGPathData.CURVE_TO]: 6,
+  [SVGPathData.SMOOTH_CURVE_TO]: 4,
+  [SVGPathData.ARC]: 7
+};
+
+// ../core/src/random.ts
+var DEFAULT_SEED = 5370206;
+function hashString(value, seed = DEFAULT_SEED) {
+  let hash = seed >>> 0;
+  for (let index = 0; index < value.length; index += 1) {
+    hash ^= value.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return hash >>> 0;
+}
+function createRandom(seed) {
+  let state = seed >>> 0;
+  return () => {
+    state += 1831565813;
+    let value = state;
+    value = Math.imul(value ^ value >>> 15, value | 1);
+    value ^= value + Math.imul(value ^ value >>> 7, value | 61);
+    return ((value ^ value >>> 14) >>> 0) / 4294967296;
+  };
+}
+
+// ../core/src/render.ts
+var DEFAULT_ROUGHNESS = 1;
+var DEFAULT_SEED2 = 0;
+var BASE_DISPLACEMENT = 0.4;
+var PATH_PRECISION = 1e3;
+function clampRoughness(value) {
+  if (value === void 0) return DEFAULT_ROUGHNESS;
+  if (!Number.isFinite(value)) throw new Error("Roughness must be a finite number.");
+  return Math.min(2, Math.max(0, value));
+}
+function normalizeSeed(value) {
+  if (value === void 0) return DEFAULT_SEED2;
+  if (!Number.isFinite(value)) throw new Error("Seed must be a finite number.");
+  return Math.trunc(value);
+}
+function randomOffset(random, amount) {
+  return (random() * 2 - 1) * amount;
+}
+function jitterPoint(point, random, amount) {
+  return {
+    x: point.x + randomOffset(random, amount),
+    y: point.y + randomOffset(random, amount)
+  };
+}
+function normalizedCommands(path) {
+  return new SVGPathData(path).toAbs().normalizeHVZ(false, true, true).normalizeST().qtToC().aToC().commands;
+}
+function sketchPass(path, roughness, seed) {
+  const commands = normalizedCommands(path);
+  const random = createRandom(seed);
+  const amount = BASE_DISPLACEMENT * roughness;
+  const output = [];
+  let sourceCurrent = { x: 0, y: 0 };
+  let outputCurrent = { x: 0, y: 0 };
+  let outputStart = { x: 0, y: 0 };
+  for (const command of commands) {
+    switch (command.type) {
+      case SVGPathData.MOVE_TO: {
+        const point = jitterPoint(command, random, amount * 0.65);
+        output.push({ type: SVGPathData.MOVE_TO, relative: false, ...point });
+        sourceCurrent = { x: command.x, y: command.y };
+        outputCurrent = point;
+        outputStart = point;
+        break;
+      }
+      case SVGPathData.LINE_TO: {
+        const dx = command.x - sourceCurrent.x;
+        const dy = command.y - sourceCurrent.y;
+        const length = Math.hypot(dx, dy);
+        const end = length < 0.5 ? { x: outputCurrent.x + dx, y: outputCurrent.y + dy } : jitterPoint(command, random, amount * 0.65);
+        const bend = randomOffset(random, Math.min(amount * 0.85, length * 0.04));
+        const normalX = length === 0 ? 0 : -dy / length;
+        const normalY = length === 0 ? 0 : dx / length;
+        output.push({
+          type: SVGPathData.CURVE_TO,
+          relative: false,
+          x1: outputCurrent.x + (end.x - outputCurrent.x) / 3 + normalX * bend,
+          y1: outputCurrent.y + (end.y - outputCurrent.y) / 3 + normalY * bend,
+          x2: outputCurrent.x + (end.x - outputCurrent.x) * 2 / 3 + normalX * bend,
+          y2: outputCurrent.y + (end.y - outputCurrent.y) * 2 / 3 + normalY * bend,
+          ...end
+        });
+        sourceCurrent = { x: command.x, y: command.y };
+        outputCurrent = end;
+        break;
+      }
+      case SVGPathData.CURVE_TO: {
+        const end = jitterPoint(command, random, amount * 0.5);
+        const firstControl = jitterPoint({ x: command.x1, y: command.y1 }, random, amount);
+        const secondControl = jitterPoint({ x: command.x2, y: command.y2 }, random, amount);
+        output.push({
+          type: SVGPathData.CURVE_TO,
+          relative: false,
+          x1: firstControl.x,
+          y1: firstControl.y,
+          x2: secondControl.x,
+          y2: secondControl.y,
+          ...end
+        });
+        sourceCurrent = { x: command.x, y: command.y };
+        outputCurrent = end;
+        break;
+      }
+      case SVGPathData.CLOSE_PATH:
+        output.push(command);
+        outputCurrent = outputStart;
+        break;
+      default:
+        throw new Error(`Unsupported normalized SVG command: ${command.type}`);
+    }
+  }
+  return new SVGPathData(output).round(PATH_PRECISION).encode();
+}
+function renderSketch(geometry, options = {}) {
+  const roughness = clampRoughness(options.roughness);
+  const seed = normalizeSeed(options.seed);
+  const output = [];
+  geometry.primitives.forEach((primitive, index) => {
+    const path = primitiveToPath(primitive);
+    const normalized = new SVGPathData(path).toAbs().round(PATH_PRECISION).encode();
+    if (roughness === 0) {
+      output.push({ d: normalized });
+      return;
+    }
+    const primitiveSeed = hashString(`${index}:${path}`, seed);
+    output.push({ d: sketchPass(path, roughness, primitiveSeed) });
+    output.push({
+      d: sketchPass(path, roughness * 0.72, primitiveSeed ^ 2654435769),
+      opacity: 0.72
+    });
+  });
+  return output;
+}
+
+export {
+  primitiveToPath,
+  renderSketch
+};