vizo-mcp 0.1.0 → 0.2.0

package/dist/index.js

@@ -245,7 +245,7 @@ function measureLine(text2, fontSize, font) {
 }
 function measureText(text2, fontSize, font) {
   const lines = text2.split("\n");
-  const width = Math.max(0, ...lines.map((l) => measureLine(l, fontSize, font)));
+  const width = Math.max(0, ...lines.map((l2) => measureLine(l2, fontSize, font)));
   const height = lines.length * fontSize * LINE_HEIGHT[font];
   return { width: Math.ceil(width), height: Math.ceil(height), lines: lines.length };
 }
@@ -253,17 +253,17 @@ function wrapText(text2, fontSize, font, maxWidth) {
   const out = [];
   for (const para of text2.split("\n")) {
     const words = para.split(/\s+/).filter(Boolean);
-    let line = "";
+    let line2 = "";
     for (const word of words) {
-      const candidate = line ? `${line} ${word}` : word;
-      if (!line || measureLine(candidate, fontSize, font) <= maxWidth) {
-        line = candidate;
+      const candidate = line2 ? `${line2} ${word}` : word;
+      if (!line2 || measureLine(candidate, fontSize, font) <= maxWidth) {
+        line2 = candidate;
       } else {
-        out.push(line);
-        line = word;
+        out.push(line2);
+        line2 = word;
       }
     }
-    out.push(line);
+    out.push(line2);
   }
   return out.join("\n");
 }
@@ -302,7 +302,7 @@ var randomNonce = () => Math.floor(Math.random() * 2 ** 31);
 function randomId(len = 20) {
   const abc = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
   const bytes = crypto.getRandomValues(new Uint8Array(len));
-  return Array.from(bytes, (b) => abc[b % abc.length]).join("");
+  return Array.from(bytes, (b2) => abc[b2 % abc.length]).join("");
 }
 function base(id2, type, x, y, width, height, o = {}) {
   return {
@@ -401,23 +401,23 @@ function arrow(id2, pts, o = {}) {
   const bind = (target, p) => {
     if (!target) return null;
     target.boundElements = [...target.boundElements ?? [], { id: id2, type: "arrow" }];
-    const b = { elementId: target.id, focus: 0, gap: 4 };
+    const b2 = { elementId: target.id, focus: 0, gap: 4 };
     if (o.elbowed) {
-      b.fixedPoint = [
+      b2.fixedPoint = [
         clamp((p[0] - target.x) / (target.width || 1), 0, 1),
         clamp((p[1] - target.y) / (target.height || 1), 0, 1)
       ];
-      b.gap = 0;
+      b2.gap = 0;
     }
-    return b;
+    return b2;
   };
   el.startBinding = bind(o.start, clean[0]);
   el.endBinding = bind(o.end, clean[clean.length - 1]);
   return el;
 }
-function arrowLabel(a, value, o = {}) {
-  const t = text(`${a.id}.t`, 0, 0, value, { textAlign: "center", verticalAlign: "middle", fontSize: 16, ...o });
-  const pts = a.points;
+function arrowLabel(a2, value, o = {}) {
+  const t = text(`${a2.id}.t`, 0, 0, value, { textAlign: "center", verticalAlign: "middle", fontSize: 16, ...o });
+  const pts = a2.points;
   let mid;
   if (pts.length % 2 === 1) mid = pts[Math.floor(pts.length / 2)];
   else {
@@ -425,12 +425,12 @@ function arrowLabel(a, value, o = {}) {
     const q = pts[pts.length / 2];
     mid = [(p[0] + q[0]) / 2, (p[1] + q[1]) / 2];
   }
-  t.containerId = a.id;
-  t.x = round(a.x + mid[0] - t.width / 2);
-  t.y = round(a.y + mid[1] - t.height / 2);
-  t.groupIds = a.groupIds ?? [];
-  if (a.customData) t.customData = { ...a.customData, role: "label" };
-  a.boundElements = [...a.boundElements ?? [], { id: t.id, type: "text" }];
+  t.containerId = a2.id;
+  t.x = round(a2.x + mid[0] - t.width / 2);
+  t.y = round(a2.y + mid[1] - t.height / 2);
+  t.groupIds = a2.groupIds ?? [];
+  if (a2.customData) t.customData = { ...a2.customData, role: "label" };
+  a2.boundElements = [...a2.boundElements ?? [], { id: t.id, type: "text" }];
   return t;
 }
 function frame(id2, x, y, w, h, name, o = {}) {
@@ -445,18 +445,18 @@ function dedupe(pts) {
   }
   const res = [];
   for (let i = 0; i < out.length; i++) {
-    const a = res[res.length - 1];
-    const b = out[i];
+    const a2 = res[res.length - 1];
+    const b2 = out[i];
     const c = out[i + 1];
-    if (a && c && (Math.abs(a[0] - b[0]) < 0.5 && Math.abs(b[0] - c[0]) < 0.5 || Math.abs(a[1] - b[1]) < 0.5 && Math.abs(b[1] - c[1]) < 0.5))
+    if (a2 && c && (Math.abs(a2[0] - b2[0]) < 0.5 && Math.abs(b2[0] - c[0]) < 0.5 || Math.abs(a2[1] - b2[1]) < 0.5 && Math.abs(b2[1] - c[1]) < 0.5))
       continue;
-    res.push(b);
+    res.push(b2);
   }
   return res.length >= 2 ? res : [out[0], [out[0][0] + 1, out[0][1]]];
 }
 var clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
 function elementBounds(els) {
-  let b = null;
+  let b2 = null;
   for (const e of els) {
     if (e.isDeleted) continue;
     let x1 = e.x, y1 = e.y, x2 = e.x + e.width, y2 = e.y + e.height;
@@ -468,15 +468,15 @@ function elementBounds(els) {
       y1 = Math.min(...ys);
       y2 = Math.max(...ys);
     }
-    if (!b) b = { minX: x1, minY: y1, maxX: x2, maxY: y2 };
+    if (!b2) b2 = { minX: x1, minY: y1, maxX: x2, maxY: y2 };
     else {
-      b.minX = Math.min(b.minX, x1);
-      b.minY = Math.min(b.minY, y1);
-      b.maxX = Math.max(b.maxX, x2);
-      b.maxY = Math.max(b.maxY, y2);
+      b2.minX = Math.min(b2.minX, x1);
+      b2.minY = Math.min(b2.minY, y1);
+      b2.maxX = Math.max(b2.maxX, x2);
+      b2.maxY = Math.max(b2.maxY, y2);
     }
   }
-  return b;
+  return b2;
 }
 function translate(els, dx, dy) {
   for (const e of els) {
@@ -567,7 +567,7 @@ async function layoutGraph(m) {
     for (let p = parentOf.get(id2); p; p = parentOf.get(p)) d++;
     return d;
   };
-  for (const g of [...m.groups].sort((a, b) => depth(a.id) - depth(b.id))) {
+  for (const g of [...m.groups].sort((a2, b2) => depth(a2.id) - depth(b2.id))) {
     const p = pos.get(g.id);
     const c = PALETTE[g.color ?? "gray"];
     const gid = `${m.idPrefix}.g.${g.id}`;
@@ -619,7 +619,7 @@ async function layoutGraph(m) {
       ];
     } else continue;
     const isSelf = e.from === e.to;
-    const a = arrow(`${m.idPrefix}.e.${e.id}`, pts, {
+    const a2 = arrow(`${m.idPrefix}.e.${e.id}`, pts, {
       start: from,
       end: to,
       startArrowhead: e.startArrowhead ?? null,
@@ -629,8 +629,8 @@ async function layoutGraph(m) {
       elbowed: m.elbowed && !isSelf && pts.length > 2,
       customData: m.customData("edge", e.id)
     });
-    edgeEls.push(a);
-    if (e.label) edgeEls.push(arrowLabel(a, e.label, { font: m.look.font }));
+    edgeEls.push(a2);
+    if (e.label) edgeEls.push(arrowLabel(a2, e.label, { font: m.look.font }));
     const endLabel = (lbl, p, q, role) => {
       if (!lbl) return;
       const dx = Math.sign(q[0] - p[0]);
@@ -639,7 +639,7 @@ async function layoutGraph(m) {
       const x = p[0] + (dx !== 0 ? dx * 8 + (dx < 0 ? -m2.width : 0) : 8);
       const y = p[1] + (dy !== 0 ? dy * 6 + (dy < 0 ? -m2.height : 0) : -m2.height - 4);
       edgeEls.push(
-        text(`${a.id}.${role}`, x, y, lbl, { fontSize: 14, font: m.look.font, customData: m.customData(role, e.id) })
+        text(`${a2.id}.${role}`, x, y, lbl, { fontSize: 14, font: m.look.font, customData: m.customData(role, e.id) })
       );
     };
     endLabel(e.fromLabel, pts[0], pts[1], "from-mult");
@@ -754,10 +754,10 @@ function classModel(spec, ctx) {
   const nodes = spec.classes.map((c) => {
     const header = (c.stereotype ? `\xAB${c.stereotype}\xBB
 ` : "") + c.name;
-    const attrs = (c.attributes ?? []).join("\n");
+    const attrs2 = (c.attributes ?? []).join("\n");
     const meths = (c.methods ?? []).join("\n");
     const hM = measureText(header, 20, font);
-    const aM = attrs ? measureText(attrs, 16, font) : { width: 0, height: 20 };
+    const aM = attrs2 ? measureText(attrs2, 16, font) : { width: 0, height: 20 };
     const mM = meths ? measureText(meths, 16, font) : { width: 0, height: 20 };
     const padX = 14;
     const w = Math.max(180, hM.width + padX * 2 + 10, aM.width + padX * 2, mM.width + padX * 2);
@@ -802,9 +802,9 @@ function classModel(spec, ctx) {
           [x + w, y + hH + aH]
         ], { kind: "line", roughness: ctx.look.roughness, groupIds: group, strokeWidth: 1 });
         els.push(div);
-        if (attrs)
+        if (attrs2)
           els.push(
-            text(`${id2}.attrs`, x + padX, y + hH + 8, attrs, { fontSize: 16, font, groupIds: group, customData: ctx.cd("class-attrs", c.id) })
+            text(`${id2}.attrs`, x + padX, y + hH + 8, attrs2, { fontSize: 16, font, groupIds: group, customData: ctx.cd("class-attrs", c.id) })
           );
         if (meths)
           els.push(
@@ -931,15 +931,15 @@ function placeRadial(root) {
   const ring = Math.max(220, maxW(root) + 80);
   const rec = (t, a0, a1, depth) => {
     const total = leaves(t);
-    let a = a0;
+    let a2 = a0;
     for (const c of t.children) {
       const share = (a1 - a0) * leaves(c) / total;
-      const mid = a + share / 2;
+      const mid = a2 + share / 2;
       const r = ring * depth + (depth === 1 ? root.w / 4 : 0);
       c.x = root.x + root.w / 2 + Math.cos(mid) * r - c.w / 2;
       c.y = root.y + root.h / 2 + Math.sin(mid) * r - c.h / 2;
-      rec(c, a, a + share, depth + 1);
-      a += share;
+      rec(c, a2, a2 + share, depth + 1);
+      a2 += share;
     }
   };
   rec(root, -Math.PI / 2, 3 * Math.PI / 2, 1);
@@ -1024,8 +1024,8 @@ function edgePoint(e, target) {
   const dy = target[1] - cy;
   if (dx === 0 && dy === 0) return [cx, cy];
   if (e.type === "ellipse") {
-    const a = e.width / 2, b = e.height / 2;
-    const t2 = 1 / Math.sqrt(dx * dx / (a * a) + dy * dy / (b * b));
+    const a2 = e.width / 2, b2 = e.height / 2;
+    const t2 = 1 / Math.sqrt(dx * dx / (a2 * a2) + dy * dy / (b2 * b2));
     return [cx + dx * t2, cy + dy * t2];
   }
   const t = Math.min(e.width / 2 / Math.abs(dx || 1e-9), e.height / 2 / Math.abs(dy || 1e-9));
@@ -1047,24 +1047,24 @@ function layoutSequence(spec, ctx) {
     const fit = fitContainer(kind, m.width, m.height, 18, 10);
     return { lbl, kind, w: Math.max(130, fit.w), h: Math.max(HEAD_H, fit.h) };
   });
-  const headH = Math.max(...boxes.map((b) => b.h));
+  const headH = Math.max(...boxes.map((b2) => b2.h));
   const gaps = P.map((_, i) => i === 0 ? 0 : Math.max(boxes[i - 1].w / 2 + boxes[i].w / 2 + 50, 180));
   const msgLabels = spec.messages.map((m) => m.label ? wrapText(m.label, MSG_FONT, font, 320) : "");
-  const order = spec.messages.map((_, i) => i).sort((a, b) => span(a) - span(b));
+  const order = spec.messages.map((_, i) => i).sort((a2, b2) => span(a2) - span(b2));
   function span(i) {
     const m = spec.messages[i];
     return Math.abs(idx.get(m.from) - idx.get(m.to));
   }
   for (const i of order) {
     const m = spec.messages[i];
-    const a = idx.get(m.from);
-    const b = idx.get(m.to);
+    const a2 = idx.get(m.from);
+    const b2 = idx.get(m.to);
     const lw = msgLabels[i] ? measureText(msgLabels[i], MSG_FONT, font).width : 0;
-    if (a === b) {
-      if (a + 1 < P.length) gaps[a + 1] = Math.max(gaps[a + 1], lw + 90);
+    if (a2 === b2) {
+      if (a2 + 1 < P.length) gaps[a2 + 1] = Math.max(gaps[a2 + 1], lw + 90);
       continue;
     }
-    const [lo, hi] = a < b ? [a, b] : [b, a];
+    const [lo, hi] = a2 < b2 ? [a2, b2] : [b2, a2];
     let cur = 0;
     for (let k = lo + 1; k <= hi; k++) cur += gaps[k];
     const need = lw + 60;
@@ -1108,8 +1108,8 @@ function layoutSequence(spec, ctx) {
   emitNotes(-1);
   spec.messages.forEach((m, i) => {
     y += (fragStarts.get(i) ?? 0) * FRAG_HEADER;
-    const a = idx.get(m.from);
-    const b = idx.get(m.to);
+    const a2 = idx.get(m.from);
+    const b2 = idx.get(m.to);
     const lbl = msgLabels[i];
     const lm = lbl ? measureText(lbl, MSG_FONT, font) : { width: 0, height: 0 };
     const top = y;
@@ -1123,29 +1123,29 @@ function layoutSequence(spec, ctx) {
       groupIds: grp,
       customData: ctx.cd("message", String(i))
     };
-    if (a === b) {
+    if (a2 === b2) {
       const ay = y + Math.max(lm.height - 6, 0);
       els.push(
         arrow(
           id2,
           [
-            [cx[a], ay],
-            [cx[a] + 50, ay],
-            [cx[a] + 50, ay + 34],
-            [cx[a] + 4, ay + 34]
+            [cx[a2], ay],
+            [cx[a2] + 50, ay],
+            [cx[a2] + 50, ay + 34],
+            [cx[a2] + 4, ay + 34]
           ],
           common2
         )
       );
-      if (lbl) els.push(text(`${id2}.t`, cx[a] + 60, ay + 17 - lm.height / 2, lbl, { fontSize: MSG_FONT, font, groupIds: grp, customData: ctx.cd("message-label", String(i)) }));
+      if (lbl) els.push(text(`${id2}.t`, cx[a2] + 60, ay + 17 - lm.height / 2, lbl, { fontSize: MSG_FONT, font, groupIds: grp, customData: ctx.cd("message-label", String(i)) }));
       y = ay + 34 + 26;
     } else {
       const ay = y + lm.height + 6;
-      const dir = Math.sign(cx[b] - cx[a]);
-      els.push(arrow(id2, [[cx[a], ay], [cx[b] - dir * 2, ay]], common2));
+      const dir = Math.sign(cx[b2] - cx[a2]);
+      els.push(arrow(id2, [[cx[a2], ay], [cx[b2] - dir * 2, ay]], common2));
       if (lbl)
         els.push(
-          text(`${id2}.t`, (cx[a] + cx[b]) / 2 - lm.width / 2, y, lbl, {
+          text(`${id2}.t`, (cx[a2] + cx[b2]) / 2 - lm.width / 2, y, lbl, {
             fontSize: MSG_FONT,
             font,
             textAlign: "center",
@@ -1190,15 +1190,15 @@ function layoutSequence(spec, ctx) {
   });
   const headEls = [];
   P.forEach((p, i) => {
-    const b = boxes[i];
+    const b2 = boxes[i];
     const id2 = `${ctx.idPrefix}.p.${p.id}`;
     const color = PALETTE[p.type === "actor" ? "pink" : p.type === "database" ? "cyan" : p.type === "external" ? "gray" : "blue"];
-    const s = shape(b.kind, id2, cx[i] - b.w / 2, (headH - b.h) / 2, b.w, b.h, {
+    const s = shape(b2.kind, id2, cx[i] - b2.w / 2, (headH - b2.h) / 2, b2.w, b2.h, {
       backgroundColor: color[1],
       roughness,
       customData: ctx.cd("participant", p.id)
     });
-    headEls.push(s, boundText(s, b.lbl, { fontSize: 18, font, strokeColor: INK }));
+    headEls.push(s, boundText(s, b2.lbl, { fontSize: 18, font, strokeColor: INK }));
     headEls.push(
       arrow(`${id2}.life`, [[cx[i], headH], [cx[i], bottom]], {
         kind: "line",
@@ -1260,11 +1260,11 @@ async function renderDiagram(spec, opts) {
       els = layoutMindmap(spec, ctx);
       break;
   }
-  const b = elementBounds(els);
+  const b2 = elementBounds(els);
   const origin = opts.origin ?? { x: 0, y: 0 };
-  translate(els, origin.x + FRAME_PAD - b.minX, origin.y + FRAME_PAD - b.minY);
-  const w = b.maxX - b.minX + FRAME_PAD * 2;
-  const h = b.maxY - b.minY + FRAME_PAD * 2;
+  translate(els, origin.x + FRAME_PAD - b2.minX, origin.y + FRAME_PAD - b2.minY);
+  const w = b2.maxX - b2.minX + FRAME_PAD * 2;
+  const h = b2.maxY - b2.minY + FRAME_PAD * 2;
   const frameId = `${opts.diagramId}.frame`;
   const f = frame(frameId, origin.x, origin.y, w, h, spec.title ?? defaultTitle(spec), {
     customData: cd("frame", opts.diagramId)
@@ -1307,18 +1307,2698 @@ var ConnectInput = z2.object({
   color: Color.optional()
 });
 
+// src/export.ts
+import { existsSync, mkdirSync, readFileSync as readFileSync2, writeFileSync } from "node:fs";
+import { dirname, extname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// ../../node_modules/.pnpm/hachure-fill@0.5.2/node_modules/hachure-fill/bin/hachure.js
+function rotatePoints(points, center, degrees) {
+  if (points && points.length) {
+    const [cx, cy] = center;
+    const angle = Math.PI / 180 * degrees;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    for (const p of points) {
+      const [x, y] = p;
+      p[0] = (x - cx) * cos - (y - cy) * sin + cx;
+      p[1] = (x - cx) * sin + (y - cy) * cos + cy;
+    }
+  }
+}
+function rotateLines(lines, center, degrees) {
+  const points = [];
+  lines.forEach((line2) => points.push(...line2));
+  rotatePoints(points, center, degrees);
+}
+function areSamePoints(p1, p2) {
+  return p1[0] === p2[0] && p1[1] === p2[1];
+}
+function hachureLines(polygons, hachureGap, hachureAngle, hachureStepOffset = 1) {
+  const angle = hachureAngle;
+  const gap = Math.max(hachureGap, 0.1);
+  const polygonList = polygons[0] && polygons[0][0] && typeof polygons[0][0] === "number" ? [polygons] : polygons;
+  const rotationCenter = [0, 0];
+  if (angle) {
+    for (const polygon2 of polygonList) {
+      rotatePoints(polygon2, rotationCenter, angle);
+    }
+  }
+  const lines = straightHachureLines(polygonList, gap, hachureStepOffset);
+  if (angle) {
+    for (const polygon2 of polygonList) {
+      rotatePoints(polygon2, rotationCenter, -angle);
+    }
+    rotateLines(lines, rotationCenter, -angle);
+  }
+  return lines;
+}
+function straightHachureLines(polygons, gap, hachureStepOffset) {
+  const vertexArray = [];
+  for (const polygon2 of polygons) {
+    const vertices = [...polygon2];
+    if (!areSamePoints(vertices[0], vertices[vertices.length - 1])) {
+      vertices.push([vertices[0][0], vertices[0][1]]);
+    }
+    if (vertices.length > 2) {
+      vertexArray.push(vertices);
+    }
+  }
+  const lines = [];
+  gap = Math.max(gap, 0.1);
+  const edges = [];
+  for (const vertices of vertexArray) {
+    for (let i = 0; i < vertices.length - 1; i++) {
+      const p1 = vertices[i];
+      const p2 = vertices[i + 1];
+      if (p1[1] !== p2[1]) {
+        const ymin = Math.min(p1[1], p2[1]);
+        edges.push({
+          ymin,
+          ymax: Math.max(p1[1], p2[1]),
+          x: ymin === p1[1] ? p1[0] : p2[0],
+          islope: (p2[0] - p1[0]) / (p2[1] - p1[1])
+        });
+      }
+    }
+  }
+  edges.sort((e1, e2) => {
+    if (e1.ymin < e2.ymin) {
+      return -1;
+    }
+    if (e1.ymin > e2.ymin) {
+      return 1;
+    }
+    if (e1.x < e2.x) {
+      return -1;
+    }
+    if (e1.x > e2.x) {
+      return 1;
+    }
+    if (e1.ymax === e2.ymax) {
+      return 0;
+    }
+    return (e1.ymax - e2.ymax) / Math.abs(e1.ymax - e2.ymax);
+  });
+  if (!edges.length) {
+    return lines;
+  }
+  let activeEdges = [];
+  let y = edges[0].ymin;
+  let iteration = 0;
+  while (activeEdges.length || edges.length) {
+    if (edges.length) {
+      let ix = -1;
+      for (let i = 0; i < edges.length; i++) {
+        if (edges[i].ymin > y) {
+          break;
+        }
+        ix = i;
+      }
+      const removed = edges.splice(0, ix + 1);
+      removed.forEach((edge) => {
+        activeEdges.push({ s: y, edge });
+      });
+    }
+    activeEdges = activeEdges.filter((ae2) => {
+      if (ae2.edge.ymax <= y) {
+        return false;
+      }
+      return true;
+    });
+    activeEdges.sort((ae1, ae2) => {
+      if (ae1.edge.x === ae2.edge.x) {
+        return 0;
+      }
+      return (ae1.edge.x - ae2.edge.x) / Math.abs(ae1.edge.x - ae2.edge.x);
+    });
+    if (hachureStepOffset !== 1 || iteration % gap === 0) {
+      if (activeEdges.length > 1) {
+        for (let i = 0; i < activeEdges.length; i = i + 2) {
+          const nexti = i + 1;
+          if (nexti >= activeEdges.length) {
+            break;
+          }
+          const ce2 = activeEdges[i].edge;
+          const ne = activeEdges[nexti].edge;
+          lines.push([
+            [Math.round(ce2.x), y],
+            [Math.round(ne.x), y]
+          ]);
+        }
+      }
+    }
+    y += hachureStepOffset;
+    activeEdges.forEach((ae2) => {
+      ae2.edge.x = ae2.edge.x + hachureStepOffset * ae2.edge.islope;
+    });
+    iteration++;
+  }
+  return lines;
+}
+
+// ../../node_modules/.pnpm/roughjs@4.6.6/node_modules/roughjs/bin/fillers/scan-line-hachure.js
+function polygonHachureLines(polygonList, o) {
+  var _a;
+  const angle = o.hachureAngle + 90;
+  let gap = o.hachureGap;
+  if (gap < 0) {
+    gap = o.strokeWidth * 4;
+  }
+  gap = Math.round(Math.max(gap, 0.1));
+  let skipOffset = 1;
+  if (o.roughness >= 1) {
+    if ((((_a = o.randomizer) === null || _a === void 0 ? void 0 : _a.next()) || Math.random()) > 0.7) {
+      skipOffset = gap;
+    }
+  }
+  return hachureLines(polygonList, gap, angle, skipOffset || 1);
+}
+
+// ../../node_modules/.pnpm/roughjs@4.6.6/node_modules/roughjs/bin/fillers/hachure-filler.js
+var HachureFiller = class {
+  constructor(helper2) {
+    this.helper = helper2;
+  }
+  fillPolygons(polygonList, o) {
+    return this._fillPolygons(polygonList, o);
+  }
+  _fillPolygons(polygonList, o) {
+    const lines = polygonHachureLines(polygonList, o);
+    const ops = this.renderLines(lines, o);
+    return { type: "fillSketch", ops };
+  }
+  renderLines(lines, o) {
+    const ops = [];
+    for (const line2 of lines) {
+      ops.push(...this.helper.doubleLineOps(line2[0][0], line2[0][1], line2[1][0], line2[1][1], o));
+    }
+    return ops;
+  }
+};
+
+// ../../node_modules/.pnpm/roughjs@4.6.6/node_modules/roughjs/bin/geometry.js
+function lineLength(line2) {
+  const p1 = line2[0];
+  const p2 = line2[1];
+  return Math.sqrt(Math.pow(p1[0] - p2[0], 2) + Math.pow(p1[1] - p2[1], 2));
+}
+
+// ../../node_modules/.pnpm/roughjs@4.6.6/node_modules/roughjs/bin/fillers/zigzag-filler.js
+var ZigZagFiller = class extends HachureFiller {
+  fillPolygons(polygonList, o) {
+    let gap = o.hachureGap;
+    if (gap < 0) {
+      gap = o.strokeWidth * 4;
+    }
+    gap = Math.max(gap, 0.1);
+    const o2 = Object.assign({}, o, { hachureGap: gap });
+    const lines = polygonHachureLines(polygonList, o2);
+    const zigZagAngle = Math.PI / 180 * o.hachureAngle;
+    const zigzagLines = [];
+    const dgx = gap * 0.5 * Math.cos(zigZagAngle);
+    const dgy = gap * 0.5 * Math.sin(zigZagAngle);
+    for (const [p1, p2] of lines) {
+      if (lineLength([p1, p2])) {
+        zigzagLines.push([
+          [p1[0] - dgx, p1[1] + dgy],
+          [...p2]
+        ], [
+          [p1[0] + dgx, p1[1] - dgy],
+          [...p2]
+        ]);
+      }
+    }
+    const ops = this.renderLines(zigzagLines, o);
+    return { type: "fillSketch", ops };
+  }
+};
+
+// ../../node_modules/.pnpm/roughjs@4.6.6/node_modules/roughjs/bin/fillers/hatch-filler.js
+var HatchFiller = class extends HachureFiller {
+  fillPolygons(polygonList, o) {
+    const set = this._fillPolygons(polygonList, o);
+    const o2 = Object.assign({}, o, { hachureAngle: o.hachureAngle + 90 });
+    const set2 = this._fillPolygons(polygonList, o2);
+    set.ops = set.ops.concat(set2.ops);
+    return set;
+  }
+};
+
+// ../../node_modules/.pnpm/roughjs@4.6.6/node_modules/roughjs/bin/fillers/dot-filler.js
+var DotFiller = class {
+  constructor(helper2) {
+    this.helper = helper2;
+  }
+  fillPolygons(polygonList, o) {
+    o = Object.assign({}, o, { hachureAngle: 0 });
+    const lines = polygonHachureLines(polygonList, o);
+    return this.dotsOnLines(lines, o);
+  }
+  dotsOnLines(lines, o) {
+    const ops = [];
+    let gap = o.hachureGap;
+    if (gap < 0) {
+      gap = o.strokeWidth * 4;
+    }
+    gap = Math.max(gap, 0.1);
+    let fweight = o.fillWeight;
+    if (fweight < 0) {
+      fweight = o.strokeWidth / 2;
+    }
+    const ro = gap / 4;
+    for (const line2 of lines) {
+      const length = lineLength(line2);
+      const dl = length / gap;
+      const count = Math.ceil(dl) - 1;
+      const offset = length - count * gap;
+      const x = (line2[0][0] + line2[1][0]) / 2 - gap / 4;
+      const minY = Math.min(line2[0][1], line2[1][1]);
+      for (let i = 0; i < count; i++) {
+        const y = minY + offset + i * gap;
+        const cx = x - ro + Math.random() * 2 * ro;
+        const cy = y - ro + Math.random() * 2 * ro;
+        const el = this.helper.ellipse(cx, cy, fweight, fweight, o);
+        ops.push(...el.ops);
+      }
+    }
+    return { type: "fillSketch", ops };
+  }
+};
+
+// ../../node_modules/.pnpm/roughjs@4.6.6/node_modules/roughjs/bin/fillers/dashed-filler.js
+var DashedFiller = class {
+  constructor(helper2) {
+    this.helper = helper2;
+  }
+  fillPolygons(polygonList, o) {
+    const lines = polygonHachureLines(polygonList, o);
+    return { type: "fillSketch", ops: this.dashedLine(lines, o) };
+  }
+  dashedLine(lines, o) {
+    const offset = o.dashOffset < 0 ? o.hachureGap < 0 ? o.strokeWidth * 4 : o.hachureGap : o.dashOffset;
+    const gap = o.dashGap < 0 ? o.hachureGap < 0 ? o.strokeWidth * 4 : o.hachureGap : o.dashGap;
+    const ops = [];
+    lines.forEach((line2) => {
+      const length = lineLength(line2);
+      const count = Math.floor(length / (offset + gap));
+      const startOffset = (length + gap - count * (offset + gap)) / 2;
+      let p1 = line2[0];
+      let p2 = line2[1];
+      if (p1[0] > p2[0]) {
+        p1 = line2[1];
+        p2 = line2[0];
+      }
+      const alpha = Math.atan((p2[1] - p1[1]) / (p2[0] - p1[0]));
+      for (let i = 0; i < count; i++) {
+        const lstart = i * (offset + gap);
+        const lend = lstart + offset;
+        const start = [p1[0] + lstart * Math.cos(alpha) + startOffset * Math.cos(alpha), p1[1] + lstart * Math.sin(alpha) + startOffset * Math.sin(alpha)];
+        const end = [p1[0] + lend * Math.cos(alpha) + startOffset * Math.cos(alpha), p1[1] + lend * Math.sin(alpha) + startOffset * Math.sin(alpha)];
+        ops.push(...this.helper.doubleLineOps(start[0], start[1], end[0], end[1], o));
+      }
+    });
+    return ops;
+  }
+};
+
+// ../../node_modules/.pnpm/roughjs@4.6.6/node_modules/roughjs/bin/fillers/zigzag-line-filler.js
+var ZigZagLineFiller = class {
+  constructor(helper2) {
+    this.helper = helper2;
+  }
+  fillPolygons(polygonList, o) {
+    const gap = o.hachureGap < 0 ? o.strokeWidth * 4 : o.hachureGap;
+    const zo = o.zigzagOffset < 0 ? gap : o.zigzagOffset;
+    o = Object.assign({}, o, { hachureGap: gap + zo });
+    const lines = polygonHachureLines(polygonList, o);
+    return { type: "fillSketch", ops: this.zigzagLines(lines, zo, o) };
+  }
+  zigzagLines(lines, zo, o) {
+    const ops = [];
+    lines.forEach((line2) => {
+      const length = lineLength(line2);
+      const count = Math.round(length / (2 * zo));
+      let p1 = line2[0];
+      let p2 = line2[1];
+      if (p1[0] > p2[0]) {
+        p1 = line2[1];
+        p2 = line2[0];
+      }
+      const alpha = Math.atan((p2[1] - p1[1]) / (p2[0] - p1[0]));
+      for (let i = 0; i < count; i++) {
+        const lstart = i * 2 * zo;
+        const lend = (i + 1) * 2 * zo;
+        const dz = Math.sqrt(2 * Math.pow(zo, 2));
+        const start = [p1[0] + lstart * Math.cos(alpha), p1[1] + lstart * Math.sin(alpha)];
+        const end = [p1[0] + lend * Math.cos(alpha), p1[1] + lend * Math.sin(alpha)];
+        const middle = [start[0] + dz * Math.cos(alpha + Math.PI / 4), start[1] + dz * Math.sin(alpha + Math.PI / 4)];
+        ops.push(...this.helper.doubleLineOps(start[0], start[1], middle[0], middle[1], o), ...this.helper.doubleLineOps(middle[0], middle[1], end[0], end[1], o));
+      }
+    });
+    return ops;
+  }
+};
+
+// ../../node_modules/.pnpm/roughjs@4.6.6/node_modules/roughjs/bin/fillers/filler.js
+var fillers = {};
+function getFiller(o, helper2) {
+  let fillerName = o.fillStyle || "hachure";
+  if (!fillers[fillerName]) {
+    switch (fillerName) {
+      case "zigzag":
+        if (!fillers[fillerName]) {
+          fillers[fillerName] = new ZigZagFiller(helper2);
+        }
+        break;
+      case "cross-hatch":
+        if (!fillers[fillerName]) {
+          fillers[fillerName] = new HatchFiller(helper2);
+        }
+        break;
+      case "dots":
+        if (!fillers[fillerName]) {
+          fillers[fillerName] = new DotFiller(helper2);
+        }
+        break;
+      case "dashed":
+        if (!fillers[fillerName]) {
+          fillers[fillerName] = new DashedFiller(helper2);
+        }
+        break;
+      case "zigzag-line":
+        if (!fillers[fillerName]) {
+          fillers[fillerName] = new ZigZagLineFiller(helper2);
+        }
+        break;
+      case "hachure":
+      default:
+        fillerName = "hachure";
+        if (!fillers[fillerName]) {
+          fillers[fillerName] = new HachureFiller(helper2);
+        }
+        break;
+    }
+  }
+  return fillers[fillerName];
+}
+
+// ../../node_modules/.pnpm/roughjs@4.6.6/node_modules/roughjs/bin/math.js
+function randomSeed() {
+  return Math.floor(Math.random() * 2 ** 31);
+}
+var Random = class {
+  constructor(seed) {
+    this.seed = seed;
+  }
+  next() {
+    if (this.seed) {
+      return (2 ** 31 - 1 & (this.seed = Math.imul(48271, this.seed))) / 2 ** 31;
+    } else {
+      return Math.random();
+    }
+  }
+};
+
+// ../../node_modules/.pnpm/path-data-parser@0.1.0/node_modules/path-data-parser/lib/parser.js
+var COMMAND = 0;
+var NUMBER = 1;
+var EOD = 2;
+var PARAMS = { A: 7, a: 7, C: 6, c: 6, H: 1, h: 1, L: 2, l: 2, M: 2, m: 2, Q: 4, q: 4, S: 4, s: 4, T: 2, t: 2, V: 1, v: 1, Z: 0, z: 0 };
+function tokenize(d) {
+  const tokens = new Array();
+  while (d !== "") {
+    if (d.match(/^([ \t\r\n,]+)/)) {
+      d = d.substr(RegExp.$1.length);
+    } else if (d.match(/^([aAcChHlLmMqQsStTvVzZ])/)) {
+      tokens[tokens.length] = { type: COMMAND, text: RegExp.$1 };
+      d = d.substr(RegExp.$1.length);
+    } else if (d.match(/^(([-+]?[0-9]+(\.[0-9]*)?|[-+]?\.[0-9]+)([eE][-+]?[0-9]+)?)/)) {
+      tokens[tokens.length] = { type: NUMBER, text: `${parseFloat(RegExp.$1)}` };
+      d = d.substr(RegExp.$1.length);
+    } else {
+      return [];
+    }
+  }
+  tokens[tokens.length] = { type: EOD, text: "" };
+  return tokens;
+}
+function isType(token, type) {
+  return token.type === type;
+}
+function parsePath(d) {
+  const segments = [];
+  const tokens = tokenize(d);
+  let mode = "BOD";
+  let index = 0;
+  let token = tokens[index];
+  while (!isType(token, EOD)) {
+    let paramsCount = 0;
+    const params = [];
+    if (mode === "BOD") {
+      if (token.text === "M" || token.text === "m") {
+        index++;
+        paramsCount = PARAMS[token.text];
+        mode = token.text;
+      } else {
+        return parsePath("M0,0" + d);
+      }
+    } else if (isType(token, NUMBER)) {
+      paramsCount = PARAMS[mode];
+    } else {
+      index++;
+      paramsCount = PARAMS[token.text];
+      mode = token.text;
+    }
+    if (index + paramsCount < tokens.length) {
+      for (let i = index; i < index + paramsCount; i++) {
+        const numbeToken = tokens[i];
+        if (isType(numbeToken, NUMBER)) {
+          params[params.length] = +numbeToken.text;
+        } else {
+          throw new Error("Param not a number: " + mode + "," + numbeToken.text);
+        }
+      }
+      if (typeof PARAMS[mode] === "number") {
+        const segment = { key: mode, data: params };
+        segments.push(segment);
+        index += paramsCount;
+        token = tokens[index];
+        if (mode === "M")
+          mode = "L";
+        if (mode === "m")
+          mode = "l";
+      } else {
+        throw new Error("Bad segment: " + mode);
+      }
+    } else {
+      throw new Error("Path data ended short");
+    }
+  }
+  return segments;
+}
+
+// ../../node_modules/.pnpm/path-data-parser@0.1.0/node_modules/path-data-parser/lib/absolutize.js
+function absolutize(segments) {
+  let cx = 0, cy = 0;
+  let subx = 0, suby = 0;
+  const out = [];
+  for (const { key, data } of segments) {
+    switch (key) {
+      case "M":
+        out.push({ key: "M", data: [...data] });
+        [cx, cy] = data;
+        [subx, suby] = data;
+        break;
+      case "m":
+        cx += data[0];
+        cy += data[1];
+        out.push({ key: "M", data: [cx, cy] });
+        subx = cx;
+        suby = cy;
+        break;
+      case "L":
+        out.push({ key: "L", data: [...data] });
+        [cx, cy] = data;
+        break;
+      case "l":
+        cx += data[0];
+        cy += data[1];
+        out.push({ key: "L", data: [cx, cy] });
+        break;
+      case "C":
+        out.push({ key: "C", data: [...data] });
+        cx = data[4];
+        cy = data[5];
+        break;
+      case "c": {
+        const newdata = data.map((d, i) => i % 2 ? d + cy : d + cx);
+        out.push({ key: "C", data: newdata });
+        cx = newdata[4];
+        cy = newdata[5];
+        break;
+      }
+      case "Q":
+        out.push({ key: "Q", data: [...data] });
+        cx = data[2];
+        cy = data[3];
+        break;
+      case "q": {
+        const newdata = data.map((d, i) => i % 2 ? d + cy : d + cx);
+        out.push({ key: "Q", data: newdata });
+        cx = newdata[2];
+        cy = newdata[3];
+        break;
+      }
+      case "A":
+        out.push({ key: "A", data: [...data] });
+        cx = data[5];
+        cy = data[6];
+        break;
+      case "a":
+        cx += data[5];
+        cy += data[6];
+        out.push({ key: "A", data: [data[0], data[1], data[2], data[3], data[4], cx, cy] });
+        break;
+      case "H":
+        out.push({ key: "H", data: [...data] });
+        cx = data[0];
+        break;
+      case "h":
+        cx += data[0];
+        out.push({ key: "H", data: [cx] });
+        break;
+      case "V":
+        out.push({ key: "V", data: [...data] });
+        cy = data[0];
+        break;
+      case "v":
+        cy += data[0];
+        out.push({ key: "V", data: [cy] });
+        break;
+      case "S":
+        out.push({ key: "S", data: [...data] });
+        cx = data[2];
+        cy = data[3];
+        break;
+      case "s": {
+        const newdata = data.map((d, i) => i % 2 ? d + cy : d + cx);
+        out.push({ key: "S", data: newdata });
+        cx = newdata[2];
+        cy = newdata[3];
+        break;
+      }
+      case "T":
+        out.push({ key: "T", data: [...data] });
+        cx = data[0];
+        cy = data[1];
+        break;
+      case "t":
+        cx += data[0];
+        cy += data[1];
+        out.push({ key: "T", data: [cx, cy] });
+        break;
+      case "Z":
+      case "z":
+        out.push({ key: "Z", data: [] });
+        cx = subx;
+        cy = suby;
+        break;
+    }
+  }
+  return out;
+}
+
+// ../../node_modules/.pnpm/path-data-parser@0.1.0/node_modules/path-data-parser/lib/normalize.js
+function normalize(segments) {
+  const out = [];
+  let lastType = "";
+  let cx = 0, cy = 0;
+  let subx = 0, suby = 0;
+  let lcx = 0, lcy = 0;
+  for (const { key, data } of segments) {
+    switch (key) {
+      case "M":
+        out.push({ key: "M", data: [...data] });
+        [cx, cy] = data;
+        [subx, suby] = data;
+        break;
+      case "C":
+        out.push({ key: "C", data: [...data] });
+        cx = data[4];
+        cy = data[5];
+        lcx = data[2];
+        lcy = data[3];
+        break;
+      case "L":
+        out.push({ key: "L", data: [...data] });
+        [cx, cy] = data;
+        break;
+      case "H":
+        cx = data[0];
+        out.push({ key: "L", data: [cx, cy] });
+        break;
+      case "V":
+        cy = data[0];
+        out.push({ key: "L", data: [cx, cy] });
+        break;
+      case "S": {
+        let cx1 = 0, cy1 = 0;
+        if (lastType === "C" || lastType === "S") {
+          cx1 = cx + (cx - lcx);
+          cy1 = cy + (cy - lcy);
+        } else {
+          cx1 = cx;
+          cy1 = cy;
+        }
+        out.push({ key: "C", data: [cx1, cy1, ...data] });
+        lcx = data[0];
+        lcy = data[1];
+        cx = data[2];
+        cy = data[3];
+        break;
+      }
+      case "T": {
+        const [x, y] = data;
+        let x1 = 0, y1 = 0;
+        if (lastType === "Q" || lastType === "T") {
+          x1 = cx + (cx - lcx);
+          y1 = cy + (cy - lcy);
+        } else {
+          x1 = cx;
+          y1 = cy;
+        }
+        const cx1 = cx + 2 * (x1 - cx) / 3;
+        const cy1 = cy + 2 * (y1 - cy) / 3;
+        const cx2 = x + 2 * (x1 - x) / 3;
+        const cy2 = y + 2 * (y1 - y) / 3;
+        out.push({ key: "C", data: [cx1, cy1, cx2, cy2, x, y] });
+        lcx = x1;
+        lcy = y1;
+        cx = x;
+        cy = y;
+        break;
+      }
+      case "Q": {
+        const [x1, y1, x, y] = data;
+        const cx1 = cx + 2 * (x1 - cx) / 3;
+        const cy1 = cy + 2 * (y1 - cy) / 3;
+        const cx2 = x + 2 * (x1 - x) / 3;
+        const cy2 = y + 2 * (y1 - y) / 3;
+        out.push({ key: "C", data: [cx1, cy1, cx2, cy2, x, y] });
+        lcx = x1;
+        lcy = y1;
+        cx = x;
+        cy = y;
+        break;
+      }
+      case "A": {
+        const r1 = Math.abs(data[0]);
+        const r22 = Math.abs(data[1]);
+        const angle = data[2];
+        const largeArcFlag = data[3];
+        const sweepFlag = data[4];
+        const x = data[5];
+        const y = data[6];
+        if (r1 === 0 || r22 === 0) {
+          out.push({ key: "C", data: [cx, cy, x, y, x, y] });
+          cx = x;
+          cy = y;
+        } else {
+          if (cx !== x || cy !== y) {
+            const curves = arcToCubicCurves(cx, cy, x, y, r1, r22, angle, largeArcFlag, sweepFlag);
+            curves.forEach(function(curve2) {
+              out.push({ key: "C", data: curve2 });
+            });
+            cx = x;
+            cy = y;
+          }
+        }
+        break;
+      }
+      case "Z":
+        out.push({ key: "Z", data: [] });
+        cx = subx;
+        cy = suby;
+        break;
+    }
+    lastType = key;
+  }
+  return out;
+}
+function degToRad(degrees) {
+  return Math.PI * degrees / 180;
+}
+function rotate(x, y, angleRad) {
+  const X = x * Math.cos(angleRad) - y * Math.sin(angleRad);
+  const Y = x * Math.sin(angleRad) + y * Math.cos(angleRad);
+  return [X, Y];
+}
+function arcToCubicCurves(x1, y1, x2, y2, r1, r22, angle, largeArcFlag, sweepFlag, recursive) {
+  const angleRad = degToRad(angle);
+  let params = [];
+  let f1 = 0, f2 = 0, cx = 0, cy = 0;
+  if (recursive) {
+    [f1, f2, cx, cy] = recursive;
+  } else {
+    [x1, y1] = rotate(x1, y1, -angleRad);
+    [x2, y2] = rotate(x2, y2, -angleRad);
+    const x = (x1 - x2) / 2;
+    const y = (y1 - y2) / 2;
+    let h = x * x / (r1 * r1) + y * y / (r22 * r22);
+    if (h > 1) {
+      h = Math.sqrt(h);
+      r1 = h * r1;
+      r22 = h * r22;
+    }
+    const sign = largeArcFlag === sweepFlag ? -1 : 1;
+    const r1Pow = r1 * r1;
+    const r2Pow = r22 * r22;
+    const left = r1Pow * r2Pow - r1Pow * y * y - r2Pow * x * x;
+    const right = r1Pow * y * y + r2Pow * x * x;
+    const k = sign * Math.sqrt(Math.abs(left / right));
+    cx = k * r1 * y / r22 + (x1 + x2) / 2;
+    cy = k * -r22 * x / r1 + (y1 + y2) / 2;
+    f1 = Math.asin(parseFloat(((y1 - cy) / r22).toFixed(9)));
+    f2 = Math.asin(parseFloat(((y2 - cy) / r22).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;
+    }
+  }
+  let df = f2 - f1;
+  if (Math.abs(df) > Math.PI * 120 / 180) {
+    const f2old = f2;
+    const x2old = x2;
+    const 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 + r22 * Math.sin(f2);
+    params = arcToCubicCurves(x2, y2, x2old, y2old, r1, r22, angle, 0, sweepFlag, [f2, f2old, cx, cy]);
+  }
+  df = f2 - f1;
+  const c1 = Math.cos(f1);
+  const s1 = Math.sin(f1);
+  const c2 = Math.cos(f2);
+  const s2 = Math.sin(f2);
+  const t = Math.tan(df / 4);
+  const hx = 4 / 3 * r1 * t;
+  const hy = 4 / 3 * r22 * t;
+  const m1 = [x1, y1];
+  const m2 = [x1 + hx * s1, y1 - hy * c1];
+  const m3 = [x2 + hx * s2, y2 - hy * c2];
+  const 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);
+    const curves = [];
+    for (let i = 0; i < params.length; i += 3) {
+      const r12 = rotate(params[i][0], params[i][1], angleRad);
+      const r23 = rotate(params[i + 1][0], params[i + 1][1], angleRad);
+      const r3 = rotate(params[i + 2][0], params[i + 2][1], angleRad);
+      curves.push([r12[0], r12[1], r23[0], r23[1], r3[0], r3[1]]);
+    }
+    return curves;
+  }
+}
+
+// ../../node_modules/.pnpm/roughjs@4.6.6/node_modules/roughjs/bin/renderer.js
+var helper = {
+  randOffset,
+  randOffsetWithRange,
+  ellipse,
+  doubleLineOps: doubleLineFillOps
+};
+function line(x1, y1, x2, y2, o) {
+  return { type: "path", ops: _doubleLine(x1, y1, x2, y2, o) };
+}
+function linearPath(points, close, o) {
+  const len = (points || []).length;
+  if (len > 2) {
+    const ops = [];
+    for (let i = 0; i < len - 1; i++) {
+      ops.push(..._doubleLine(points[i][0], points[i][1], points[i + 1][0], points[i + 1][1], o));
+    }
+    if (close) {
+      ops.push(..._doubleLine(points[len - 1][0], points[len - 1][1], points[0][0], points[0][1], o));
+    }
+    return { type: "path", ops };
+  } else if (len === 2) {
+    return line(points[0][0], points[0][1], points[1][0], points[1][1], o);
+  }
+  return { type: "path", ops: [] };
+}
+function polygon(points, o) {
+  return linearPath(points, true, o);
+}
+function rectangle(x, y, width, height, o) {
+  const points = [
+    [x, y],
+    [x + width, y],
+    [x + width, y + height],
+    [x, y + height]
+  ];
+  return polygon(points, o);
+}
+function curve(inputPoints, o) {
+  if (inputPoints.length) {
+    const p1 = inputPoints[0];
+    const pointsList = typeof p1[0] === "number" ? [inputPoints] : inputPoints;
+    const o1 = _curveWithOffset(pointsList[0], 1 * (1 + o.roughness * 0.2), o);
+    const o2 = o.disableMultiStroke ? [] : _curveWithOffset(pointsList[0], 1.5 * (1 + o.roughness * 0.22), cloneOptionsAlterSeed(o));
+    for (let i = 1; i < pointsList.length; i++) {
+      const points = pointsList[i];
+      if (points.length) {
+        const underlay = _curveWithOffset(points, 1 * (1 + o.roughness * 0.2), o);
+        const overlay = o.disableMultiStroke ? [] : _curveWithOffset(points, 1.5 * (1 + o.roughness * 0.22), cloneOptionsAlterSeed(o));
+        for (const item of underlay) {
+          if (item.op !== "move") {
+            o1.push(item);
+          }
+        }
+        for (const item of overlay) {
+          if (item.op !== "move") {
+            o2.push(item);
+          }
+        }
+      }
+    }
+    return { type: "path", ops: o1.concat(o2) };
+  }
+  return { type: "path", ops: [] };
+}
+function ellipse(x, y, width, height, o) {
+  const params = generateEllipseParams(width, height, o);
+  return ellipseWithParams(x, y, o, params).opset;
+}
+function generateEllipseParams(width, height, o) {
+  const psq = Math.sqrt(Math.PI * 2 * Math.sqrt((Math.pow(width / 2, 2) + Math.pow(height / 2, 2)) / 2));
+  const stepCount = Math.ceil(Math.max(o.curveStepCount, o.curveStepCount / Math.sqrt(200) * psq));
+  const increment = Math.PI * 2 / stepCount;
+  let rx = Math.abs(width / 2);
+  let ry = Math.abs(height / 2);
+  const curveFitRandomness = 1 - o.curveFitting;
+  rx += _offsetOpt(rx * curveFitRandomness, o);
+  ry += _offsetOpt(ry * curveFitRandomness, o);
+  return { increment, rx, ry };
+}
+function ellipseWithParams(x, y, o, ellipseParams) {
+  const [ap1, cp1] = _computeEllipsePoints(ellipseParams.increment, x, y, ellipseParams.rx, ellipseParams.ry, 1, ellipseParams.increment * _offset(0.1, _offset(0.4, 1, o), o), o);
+  let o1 = _curve(ap1, null, o);
+  if (!o.disableMultiStroke && o.roughness !== 0) {
+    const [ap2] = _computeEllipsePoints(ellipseParams.increment, x, y, ellipseParams.rx, ellipseParams.ry, 1.5, 0, o);
+    const o2 = _curve(ap2, null, o);
+    o1 = o1.concat(o2);
+  }
+  return {
+    estimatedPoints: cp1,
+    opset: { type: "path", ops: o1 }
+  };
+}
+function arc(x, y, width, height, start, stop, closed, roughClosure, o) {
+  const cx = x;
+  const cy = y;
+  let rx = Math.abs(width / 2);
+  let ry = Math.abs(height / 2);
+  rx += _offsetOpt(rx * 0.01, o);
+  ry += _offsetOpt(ry * 0.01, o);
+  let strt = start;
+  let stp = stop;
+  while (strt < 0) {
+    strt += Math.PI * 2;
+    stp += Math.PI * 2;
+  }
+  if (stp - strt > Math.PI * 2) {
+    strt = 0;
+    stp = Math.PI * 2;
+  }
+  const ellipseInc = Math.PI * 2 / o.curveStepCount;
+  const arcInc = Math.min(ellipseInc / 2, (stp - strt) / 2);
+  const ops = _arc(arcInc, cx, cy, rx, ry, strt, stp, 1, o);
+  if (!o.disableMultiStroke) {
+    const o2 = _arc(arcInc, cx, cy, rx, ry, strt, stp, 1.5, o);
+    ops.push(...o2);
+  }
+  if (closed) {
+    if (roughClosure) {
+      ops.push(..._doubleLine(cx, cy, cx + rx * Math.cos(strt), cy + ry * Math.sin(strt), o), ..._doubleLine(cx, cy, cx + rx * Math.cos(stp), cy + ry * Math.sin(stp), o));
+    } else {
+      ops.push({ op: "lineTo", data: [cx, cy] }, { op: "lineTo", data: [cx + rx * Math.cos(strt), cy + ry * Math.sin(strt)] });
+    }
+  }
+  return { type: "path", ops };
+}
+function svgPath(path, o) {
+  const segments = normalize(absolutize(parsePath(path)));
+  const ops = [];
+  let first = [0, 0];
+  let current = [0, 0];
+  for (const { key, data } of segments) {
+    switch (key) {
+      case "M": {
+        current = [data[0], data[1]];
+        first = [data[0], data[1]];
+        break;
+      }
+      case "L":
+        ops.push(..._doubleLine(current[0], current[1], data[0], data[1], o));
+        current = [data[0], data[1]];
+        break;
+      case "C": {
+        const [x1, y1, x2, y2, x, y] = data;
+        ops.push(..._bezierTo(x1, y1, x2, y2, x, y, current, o));
+        current = [x, y];
+        break;
+      }
+      case "Z":
+        ops.push(..._doubleLine(current[0], current[1], first[0], first[1], o));
+        current = [first[0], first[1]];
+        break;
+    }
+  }
+  return { type: "path", ops };
+}
+function solidFillPolygon(polygonList, o) {
+  const ops = [];
+  for (const points of polygonList) {
+    if (points.length) {
+      const offset = o.maxRandomnessOffset || 0;
+      const len = points.length;
+      if (len > 2) {
+        ops.push({ op: "move", data: [points[0][0] + _offsetOpt(offset, o), points[0][1] + _offsetOpt(offset, o)] });
+        for (let i = 1; i < len; i++) {
+          ops.push({ op: "lineTo", data: [points[i][0] + _offsetOpt(offset, o), points[i][1] + _offsetOpt(offset, o)] });
+        }
+      }
+    }
+  }
+  return { type: "fillPath", ops };
+}
+function patternFillPolygons(polygonList, o) {
+  return getFiller(o, helper).fillPolygons(polygonList, o);
+}
+function patternFillArc(x, y, width, height, start, stop, o) {
+  const cx = x;
+  const cy = y;
+  let rx = Math.abs(width / 2);
+  let ry = Math.abs(height / 2);
+  rx += _offsetOpt(rx * 0.01, o);
+  ry += _offsetOpt(ry * 0.01, o);
+  let strt = start;
+  let stp = stop;
+  while (strt < 0) {
+    strt += Math.PI * 2;
+    stp += Math.PI * 2;
+  }
+  if (stp - strt > Math.PI * 2) {
+    strt = 0;
+    stp = Math.PI * 2;
+  }
+  const increment = (stp - strt) / o.curveStepCount;
+  const points = [];
+  for (let angle = strt; angle <= stp; angle = angle + increment) {
+    points.push([cx + rx * Math.cos(angle), cy + ry * Math.sin(angle)]);
+  }
+  points.push([cx + rx * Math.cos(stp), cy + ry * Math.sin(stp)]);
+  points.push([cx, cy]);
+  return patternFillPolygons([points], o);
+}
+function randOffset(x, o) {
+  return _offsetOpt(x, o);
+}
+function randOffsetWithRange(min, max, o) {
+  return _offset(min, max, o);
+}
+function doubleLineFillOps(x1, y1, x2, y2, o) {
+  return _doubleLine(x1, y1, x2, y2, o, true);
+}
+function cloneOptionsAlterSeed(ops) {
+  const result = Object.assign({}, ops);
+  result.randomizer = void 0;
+  if (ops.seed) {
+    result.seed = ops.seed + 1;
+  }
+  return result;
+}
+function random(ops) {
+  if (!ops.randomizer) {
+    ops.randomizer = new Random(ops.seed || 0);
+  }
+  return ops.randomizer.next();
+}
+function _offset(min, max, ops, roughnessGain = 1) {
+  return ops.roughness * roughnessGain * (random(ops) * (max - min) + min);
+}
+function _offsetOpt(x, ops, roughnessGain = 1) {
+  return _offset(-x, x, ops, roughnessGain);
+}
+function _doubleLine(x1, y1, x2, y2, o, filling = false) {
+  const singleStroke = filling ? o.disableMultiStrokeFill : o.disableMultiStroke;
+  const o1 = _line(x1, y1, x2, y2, o, true, false);
+  if (singleStroke) {
+    return o1;
+  }
+  const o2 = _line(x1, y1, x2, y2, o, true, true);
+  return o1.concat(o2);
+}
+function _line(x1, y1, x2, y2, o, move, overlay) {
+  const lengthSq = Math.pow(x1 - x2, 2) + Math.pow(y1 - y2, 2);
+  const length = Math.sqrt(lengthSq);
+  let roughnessGain = 1;
+  if (length < 200) {
+    roughnessGain = 1;
+  } else if (length > 500) {
+    roughnessGain = 0.4;
+  } else {
+    roughnessGain = -16668e-7 * length + 1.233334;
+  }
+  let offset = o.maxRandomnessOffset || 0;
+  if (offset * offset * 100 > lengthSq) {
+    offset = length / 10;
+  }
+  const halfOffset = offset / 2;
+  const divergePoint = 0.2 + random(o) * 0.2;
+  let midDispX = o.bowing * o.maxRandomnessOffset * (y2 - y1) / 200;
+  let midDispY = o.bowing * o.maxRandomnessOffset * (x1 - x2) / 200;
+  midDispX = _offsetOpt(midDispX, o, roughnessGain);
+  midDispY = _offsetOpt(midDispY, o, roughnessGain);
+  const ops = [];
+  const randomHalf = () => _offsetOpt(halfOffset, o, roughnessGain);
+  const randomFull = () => _offsetOpt(offset, o, roughnessGain);
+  const preserveVertices = o.preserveVertices;
+  if (move) {
+    if (overlay) {
+      ops.push({
+        op: "move",
+        data: [
+          x1 + (preserveVertices ? 0 : randomHalf()),
+          y1 + (preserveVertices ? 0 : randomHalf())
+        ]
+      });
+    } else {
+      ops.push({
+        op: "move",
+        data: [
+          x1 + (preserveVertices ? 0 : _offsetOpt(offset, o, roughnessGain)),
+          y1 + (preserveVertices ? 0 : _offsetOpt(offset, o, roughnessGain))
+        ]
+      });
+    }
+  }
+  if (overlay) {
+    ops.push({
+      op: "bcurveTo",
+      data: [
+        midDispX + x1 + (x2 - x1) * divergePoint + randomHalf(),
+        midDispY + y1 + (y2 - y1) * divergePoint + randomHalf(),
+        midDispX + x1 + 2 * (x2 - x1) * divergePoint + randomHalf(),
+        midDispY + y1 + 2 * (y2 - y1) * divergePoint + randomHalf(),
+        x2 + (preserveVertices ? 0 : randomHalf()),
+        y2 + (preserveVertices ? 0 : randomHalf())
+      ]
+    });
+  } else {
+    ops.push({
+      op: "bcurveTo",
+      data: [
+        midDispX + x1 + (x2 - x1) * divergePoint + randomFull(),
+        midDispY + y1 + (y2 - y1) * divergePoint + randomFull(),
+        midDispX + x1 + 2 * (x2 - x1) * divergePoint + randomFull(),
+        midDispY + y1 + 2 * (y2 - y1) * divergePoint + randomFull(),
+        x2 + (preserveVertices ? 0 : randomFull()),
+        y2 + (preserveVertices ? 0 : randomFull())
+      ]
+    });
+  }
+  return ops;
+}
+function _curveWithOffset(points, offset, o) {
+  if (!points.length) {
+    return [];
+  }
+  const ps = [];
+  ps.push([
+    points[0][0] + _offsetOpt(offset, o),
+    points[0][1] + _offsetOpt(offset, o)
+  ]);
+  ps.push([
+    points[0][0] + _offsetOpt(offset, o),
+    points[0][1] + _offsetOpt(offset, o)
+  ]);
+  for (let i = 1; i < points.length; i++) {
+    ps.push([
+      points[i][0] + _offsetOpt(offset, o),
+      points[i][1] + _offsetOpt(offset, o)
+    ]);
+    if (i === points.length - 1) {
+      ps.push([
+        points[i][0] + _offsetOpt(offset, o),
+        points[i][1] + _offsetOpt(offset, o)
+      ]);
+    }
+  }
+  return _curve(ps, null, o);
+}
+function _curve(points, closePoint, o) {
+  const len = points.length;
+  const ops = [];
+  if (len > 3) {
+    const b2 = [];
+    const s = 1 - o.curveTightness;
+    ops.push({ op: "move", data: [points[1][0], points[1][1]] });
+    for (let i = 1; i + 2 < len; i++) {
+      const cachedVertArray = points[i];
+      b2[0] = [cachedVertArray[0], cachedVertArray[1]];
+      b2[1] = [cachedVertArray[0] + (s * points[i + 1][0] - s * points[i - 1][0]) / 6, cachedVertArray[1] + (s * points[i + 1][1] - s * points[i - 1][1]) / 6];
+      b2[2] = [points[i + 1][0] + (s * points[i][0] - s * points[i + 2][0]) / 6, points[i + 1][1] + (s * points[i][1] - s * points[i + 2][1]) / 6];
+      b2[3] = [points[i + 1][0], points[i + 1][1]];
+      ops.push({ op: "bcurveTo", data: [b2[1][0], b2[1][1], b2[2][0], b2[2][1], b2[3][0], b2[3][1]] });
+    }
+    if (closePoint && closePoint.length === 2) {
+      const ro = o.maxRandomnessOffset;
+      ops.push({ op: "lineTo", data: [closePoint[0] + _offsetOpt(ro, o), closePoint[1] + _offsetOpt(ro, o)] });
+    }
+  } else if (len === 3) {
+    ops.push({ op: "move", data: [points[1][0], points[1][1]] });
+    ops.push({
+      op: "bcurveTo",
+      data: [
+        points[1][0],
+        points[1][1],
+        points[2][0],
+        points[2][1],
+        points[2][0],
+        points[2][1]
+      ]
+    });
+  } else if (len === 2) {
+    ops.push(..._line(points[0][0], points[0][1], points[1][0], points[1][1], o, true, true));
+  }
+  return ops;
+}
+function _computeEllipsePoints(increment, cx, cy, rx, ry, offset, overlap, o) {
+  const coreOnly = o.roughness === 0;
+  const corePoints = [];
+  const allPoints = [];
+  if (coreOnly) {
+    increment = increment / 4;
+    allPoints.push([
+      cx + rx * Math.cos(-increment),
+      cy + ry * Math.sin(-increment)
+    ]);
+    for (let angle = 0; angle <= Math.PI * 2; angle = angle + increment) {
+      const p = [
+        cx + rx * Math.cos(angle),
+        cy + ry * Math.sin(angle)
+      ];
+      corePoints.push(p);
+      allPoints.push(p);
+    }
+    allPoints.push([
+      cx + rx * Math.cos(0),
+      cy + ry * Math.sin(0)
+    ]);
+    allPoints.push([
+      cx + rx * Math.cos(increment),
+      cy + ry * Math.sin(increment)
+    ]);
+  } else {
+    const radOffset = _offsetOpt(0.5, o) - Math.PI / 2;
+    allPoints.push([
+      _offsetOpt(offset, o) + cx + 0.9 * rx * Math.cos(radOffset - increment),
+      _offsetOpt(offset, o) + cy + 0.9 * ry * Math.sin(radOffset - increment)
+    ]);
+    const endAngle = Math.PI * 2 + radOffset - 0.01;
+    for (let angle = radOffset; angle < endAngle; angle = angle + increment) {
+      const p = [
+        _offsetOpt(offset, o) + cx + rx * Math.cos(angle),
+        _offsetOpt(offset, o) + cy + ry * Math.sin(angle)
+      ];
+      corePoints.push(p);
+      allPoints.push(p);
+    }
+    allPoints.push([
+      _offsetOpt(offset, o) + cx + rx * Math.cos(radOffset + Math.PI * 2 + overlap * 0.5),
+      _offsetOpt(offset, o) + cy + ry * Math.sin(radOffset + Math.PI * 2 + overlap * 0.5)
+    ]);
+    allPoints.push([
+      _offsetOpt(offset, o) + cx + 0.98 * rx * Math.cos(radOffset + overlap),
+      _offsetOpt(offset, o) + cy + 0.98 * ry * Math.sin(radOffset + overlap)
+    ]);
+    allPoints.push([
+      _offsetOpt(offset, o) + cx + 0.9 * rx * Math.cos(radOffset + overlap * 0.5),
+      _offsetOpt(offset, o) + cy + 0.9 * ry * Math.sin(radOffset + overlap * 0.5)
+    ]);
+  }
+  return [allPoints, corePoints];
+}
+function _arc(increment, cx, cy, rx, ry, strt, stp, offset, o) {
+  const radOffset = strt + _offsetOpt(0.1, o);
+  const points = [];
+  points.push([
+    _offsetOpt(offset, o) + cx + 0.9 * rx * Math.cos(radOffset - increment),
+    _offsetOpt(offset, o) + cy + 0.9 * ry * Math.sin(radOffset - increment)
+  ]);
+  for (let angle = radOffset; angle <= stp; angle = angle + increment) {
+    points.push([
+      _offsetOpt(offset, o) + cx + rx * Math.cos(angle),
+      _offsetOpt(offset, o) + cy + ry * Math.sin(angle)
+    ]);
+  }
+  points.push([
+    cx + rx * Math.cos(stp),
+    cy + ry * Math.sin(stp)
+  ]);
+  points.push([
+    cx + rx * Math.cos(stp),
+    cy + ry * Math.sin(stp)
+  ]);
+  return _curve(points, null, o);
+}
+function _bezierTo(x1, y1, x2, y2, x, y, current, o) {
+  const ops = [];
+  const ros = [o.maxRandomnessOffset || 1, (o.maxRandomnessOffset || 1) + 0.3];
+  let f = [0, 0];
+  const iterations = o.disableMultiStroke ? 1 : 2;
+  const preserveVertices = o.preserveVertices;
+  for (let i = 0; i < iterations; i++) {
+    if (i === 0) {
+      ops.push({ op: "move", data: [current[0], current[1]] });
+    } else {
+      ops.push({ op: "move", data: [current[0] + (preserveVertices ? 0 : _offsetOpt(ros[0], o)), current[1] + (preserveVertices ? 0 : _offsetOpt(ros[0], o))] });
+    }
+    f = preserveVertices ? [x, y] : [x + _offsetOpt(ros[i], o), y + _offsetOpt(ros[i], o)];
+    ops.push({
+      op: "bcurveTo",
+      data: [
+        x1 + _offsetOpt(ros[i], o),
+        y1 + _offsetOpt(ros[i], o),
+        x2 + _offsetOpt(ros[i], o),
+        y2 + _offsetOpt(ros[i], o),
+        f[0],
+        f[1]
+      ]
+    });
+  }
+  return ops;
+}
+
+// ../../node_modules/.pnpm/points-on-curve@0.2.0/node_modules/points-on-curve/lib/curve-to-bezier.js
+function clone(p) {
+  return [...p];
+}
+function curveToBezier(pointsIn, curveTightness = 0) {
+  const len = pointsIn.length;
+  if (len < 3) {
+    throw new Error("A curve must have at least three points.");
+  }
+  const out = [];
+  if (len === 3) {
+    out.push(clone(pointsIn[0]), clone(pointsIn[1]), clone(pointsIn[2]), clone(pointsIn[2]));
+  } else {
+    const points = [];
+    points.push(pointsIn[0], pointsIn[0]);
+    for (let i = 1; i < pointsIn.length; i++) {
+      points.push(pointsIn[i]);
+      if (i === pointsIn.length - 1) {
+        points.push(pointsIn[i]);
+      }
+    }
+    const b2 = [];
+    const s = 1 - curveTightness;
+    out.push(clone(points[0]));
+    for (let i = 1; i + 2 < points.length; i++) {
+      const cachedVertArray = points[i];
+      b2[0] = [cachedVertArray[0], cachedVertArray[1]];
+      b2[1] = [cachedVertArray[0] + (s * points[i + 1][0] - s * points[i - 1][0]) / 6, cachedVertArray[1] + (s * points[i + 1][1] - s * points[i - 1][1]) / 6];
+      b2[2] = [points[i + 1][0] + (s * points[i][0] - s * points[i + 2][0]) / 6, points[i + 1][1] + (s * points[i][1] - s * points[i + 2][1]) / 6];
+      b2[3] = [points[i + 1][0], points[i + 1][1]];
+      out.push(b2[1], b2[2], b2[3]);
+    }
+  }
+  return out;
+}
+
+// ../../node_modules/.pnpm/points-on-curve@0.2.0/node_modules/points-on-curve/lib/index.js
+function distance(p1, p2) {
+  return Math.sqrt(distanceSq(p1, p2));
+}
+function distanceSq(p1, p2) {
+  return Math.pow(p1[0] - p2[0], 2) + Math.pow(p1[1] - p2[1], 2);
+}
+function distanceToSegmentSq(p, v, w) {
+  const l2 = distanceSq(v, w);
+  if (l2 === 0) {
+    return distanceSq(p, v);
+  }
+  let t = ((p[0] - v[0]) * (w[0] - v[0]) + (p[1] - v[1]) * (w[1] - v[1])) / l2;
+  t = Math.max(0, Math.min(1, t));
+  return distanceSq(p, lerp(v, w, t));
+}
+function lerp(a2, b2, t) {
+  return [
+    a2[0] + (b2[0] - a2[0]) * t,
+    a2[1] + (b2[1] - a2[1]) * t
+  ];
+}
+function flatness(points, offset) {
+  const p1 = points[offset + 0];
+  const p2 = points[offset + 1];
+  const p3 = points[offset + 2];
+  const p4 = points[offset + 3];
+  let ux = 3 * p2[0] - 2 * p1[0] - p4[0];
+  ux *= ux;
+  let uy = 3 * p2[1] - 2 * p1[1] - p4[1];
+  uy *= uy;
+  let vx = 3 * p3[0] - 2 * p4[0] - p1[0];
+  vx *= vx;
+  let vy = 3 * p3[1] - 2 * p4[1] - p1[1];
+  vy *= vy;
+  if (ux < vx) {
+    ux = vx;
+  }
+  if (uy < vy) {
+    uy = vy;
+  }
+  return ux + uy;
+}
+function getPointsOnBezierCurveWithSplitting(points, offset, tolerance, newPoints) {
+  const outPoints = newPoints || [];
+  if (flatness(points, offset) < tolerance) {
+    const p0 = points[offset + 0];
+    if (outPoints.length) {
+      const d = distance(outPoints[outPoints.length - 1], p0);
+      if (d > 1) {
+        outPoints.push(p0);
+      }
+    } else {
+      outPoints.push(p0);
+    }
+    outPoints.push(points[offset + 3]);
+  } else {
+    const t = 0.5;
+    const p1 = points[offset + 0];
+    const p2 = points[offset + 1];
+    const p3 = points[offset + 2];
+    const p4 = points[offset + 3];
+    const q1 = lerp(p1, p2, t);
+    const q2 = lerp(p2, p3, t);
+    const q3 = lerp(p3, p4, t);
+    const r1 = lerp(q1, q2, t);
+    const r22 = lerp(q2, q3, t);
+    const red = lerp(r1, r22, t);
+    getPointsOnBezierCurveWithSplitting([p1, q1, r1, red], 0, tolerance, outPoints);
+    getPointsOnBezierCurveWithSplitting([red, r22, q3, p4], 0, tolerance, outPoints);
+  }
+  return outPoints;
+}
+function simplify(points, distance2) {
+  return simplifyPoints(points, 0, points.length, distance2);
+}
+function simplifyPoints(points, start, end, epsilon, newPoints) {
+  const outPoints = newPoints || [];
+  const s = points[start];
+  const e = points[end - 1];
+  let maxDistSq = 0;
+  let maxNdx = 1;
+  for (let i = start + 1; i < end - 1; ++i) {
+    const distSq = distanceToSegmentSq(points[i], s, e);
+    if (distSq > maxDistSq) {
+      maxDistSq = distSq;
+      maxNdx = i;
+    }
+  }
+  if (Math.sqrt(maxDistSq) > epsilon) {
+    simplifyPoints(points, start, maxNdx + 1, epsilon, outPoints);
+    simplifyPoints(points, maxNdx, end, epsilon, outPoints);
+  } else {
+    if (!outPoints.length) {
+      outPoints.push(s);
+    }
+    outPoints.push(e);
+  }
+  return outPoints;
+}
+function pointsOnBezierCurves(points, tolerance = 0.15, distance2) {
+  const newPoints = [];
+  const numSegments = (points.length - 1) / 3;
+  for (let i = 0; i < numSegments; i++) {
+    const offset = i * 3;
+    getPointsOnBezierCurveWithSplitting(points, offset, tolerance, newPoints);
+  }
+  if (distance2 && distance2 > 0) {
+    return simplifyPoints(newPoints, 0, newPoints.length, distance2);
+  }
+  return newPoints;
+}
+
+// ../../node_modules/.pnpm/points-on-path@0.2.1/node_modules/points-on-path/lib/index.js
+function pointsOnPath(path, tolerance, distance2) {
+  const segments = parsePath(path);
+  const normalized = normalize(absolutize(segments));
+  const sets = [];
+  let currentPoints = [];
+  let start = [0, 0];
+  let pendingCurve = [];
+  const appendPendingCurve = () => {
+    if (pendingCurve.length >= 4) {
+      currentPoints.push(...pointsOnBezierCurves(pendingCurve, tolerance));
+    }
+    pendingCurve = [];
+  };
+  const appendPendingPoints = () => {
+    appendPendingCurve();
+    if (currentPoints.length) {
+      sets.push(currentPoints);
+      currentPoints = [];
+    }
+  };
+  for (const { key, data } of normalized) {
+    switch (key) {
+      case "M":
+        appendPendingPoints();
+        start = [data[0], data[1]];
+        currentPoints.push(start);
+        break;
+      case "L":
+        appendPendingCurve();
+        currentPoints.push([data[0], data[1]]);
+        break;
+      case "C":
+        if (!pendingCurve.length) {
+          const lastPoint = currentPoints.length ? currentPoints[currentPoints.length - 1] : start;
+          pendingCurve.push([lastPoint[0], lastPoint[1]]);
+        }
+        pendingCurve.push([data[0], data[1]]);
+        pendingCurve.push([data[2], data[3]]);
+        pendingCurve.push([data[4], data[5]]);
+        break;
+      case "Z":
+        appendPendingCurve();
+        currentPoints.push([start[0], start[1]]);
+        break;
+    }
+  }
+  appendPendingPoints();
+  if (!distance2) {
+    return sets;
+  }
+  const out = [];
+  for (const set of sets) {
+    const simplifiedSet = simplify(set, distance2);
+    if (simplifiedSet.length) {
+      out.push(simplifiedSet);
+    }
+  }
+  return out;
+}
+
+// ../../node_modules/.pnpm/roughjs@4.6.6/node_modules/roughjs/bin/generator.js
+var NOS = "none";
+var RoughGenerator = class {
+  constructor(config) {
+    this.defaultOptions = {
+      maxRandomnessOffset: 2,
+      roughness: 1,
+      bowing: 1,
+      stroke: "#000",
+      strokeWidth: 1,
+      curveTightness: 0,
+      curveFitting: 0.95,
+      curveStepCount: 9,
+      fillStyle: "hachure",
+      fillWeight: -1,
+      hachureAngle: -41,
+      hachureGap: -1,
+      dashOffset: -1,
+      dashGap: -1,
+      zigzagOffset: -1,
+      seed: 0,
+      disableMultiStroke: false,
+      disableMultiStrokeFill: false,
+      preserveVertices: false,
+      fillShapeRoughnessGain: 0.8
+    };
+    this.config = config || {};
+    if (this.config.options) {
+      this.defaultOptions = this._o(this.config.options);
+    }
+  }
+  static newSeed() {
+    return randomSeed();
+  }
+  _o(options) {
+    return options ? Object.assign({}, this.defaultOptions, options) : this.defaultOptions;
+  }
+  _d(shape2, sets, options) {
+    return { shape: shape2, sets: sets || [], options: options || this.defaultOptions };
+  }
+  line(x1, y1, x2, y2, options) {
+    const o = this._o(options);
+    return this._d("line", [line(x1, y1, x2, y2, o)], o);
+  }
+  rectangle(x, y, width, height, options) {
+    const o = this._o(options);
+    const paths = [];
+    const outline = rectangle(x, y, width, height, o);
+    if (o.fill) {
+      const points = [[x, y], [x + width, y], [x + width, y + height], [x, y + height]];
+      if (o.fillStyle === "solid") {
+        paths.push(solidFillPolygon([points], o));
+      } else {
+        paths.push(patternFillPolygons([points], o));
+      }
+    }
+    if (o.stroke !== NOS) {
+      paths.push(outline);
+    }
+    return this._d("rectangle", paths, o);
+  }
+  ellipse(x, y, width, height, options) {
+    const o = this._o(options);
+    const paths = [];
+    const ellipseParams = generateEllipseParams(width, height, o);
+    const ellipseResponse = ellipseWithParams(x, y, o, ellipseParams);
+    if (o.fill) {
+      if (o.fillStyle === "solid") {
+        const shape2 = ellipseWithParams(x, y, o, ellipseParams).opset;
+        shape2.type = "fillPath";
+        paths.push(shape2);
+      } else {
+        paths.push(patternFillPolygons([ellipseResponse.estimatedPoints], o));
+      }
+    }
+    if (o.stroke !== NOS) {
+      paths.push(ellipseResponse.opset);
+    }
+    return this._d("ellipse", paths, o);
+  }
+  circle(x, y, diameter, options) {
+    const ret = this.ellipse(x, y, diameter, diameter, options);
+    ret.shape = "circle";
+    return ret;
+  }
+  linearPath(points, options) {
+    const o = this._o(options);
+    return this._d("linearPath", [linearPath(points, false, o)], o);
+  }
+  arc(x, y, width, height, start, stop, closed = false, options) {
+    const o = this._o(options);
+    const paths = [];
+    const outline = arc(x, y, width, height, start, stop, closed, true, o);
+    if (closed && o.fill) {
+      if (o.fillStyle === "solid") {
+        const fillOptions = Object.assign({}, o);
+        fillOptions.disableMultiStroke = true;
+        const shape2 = arc(x, y, width, height, start, stop, true, false, fillOptions);
+        shape2.type = "fillPath";
+        paths.push(shape2);
+      } else {
+        paths.push(patternFillArc(x, y, width, height, start, stop, o));
+      }
+    }
+    if (o.stroke !== NOS) {
+      paths.push(outline);
+    }
+    return this._d("arc", paths, o);
+  }
+  curve(points, options) {
+    const o = this._o(options);
+    const paths = [];
+    const outline = curve(points, o);
+    if (o.fill && o.fill !== NOS) {
+      if (o.fillStyle === "solid") {
+        const fillShape = curve(points, Object.assign(Object.assign({}, o), { disableMultiStroke: true, roughness: o.roughness ? o.roughness + o.fillShapeRoughnessGain : 0 }));
+        paths.push({
+          type: "fillPath",
+          ops: this._mergedShape(fillShape.ops)
+        });
+      } else {
+        const polyPoints = [];
+        const inputPoints = points;
+        if (inputPoints.length) {
+          const p1 = inputPoints[0];
+          const pointsList = typeof p1[0] === "number" ? [inputPoints] : inputPoints;
+          for (const points2 of pointsList) {
+            if (points2.length < 3) {
+              polyPoints.push(...points2);
+            } else if (points2.length === 3) {
+              polyPoints.push(...pointsOnBezierCurves(curveToBezier([
+                points2[0],
+                points2[0],
+                points2[1],
+                points2[2]
+              ]), 10, (1 + o.roughness) / 2));
+            } else {
+              polyPoints.push(...pointsOnBezierCurves(curveToBezier(points2), 10, (1 + o.roughness) / 2));
+            }
+          }
+        }
+        if (polyPoints.length) {
+          paths.push(patternFillPolygons([polyPoints], o));
+        }
+      }
+    }
+    if (o.stroke !== NOS) {
+      paths.push(outline);
+    }
+    return this._d("curve", paths, o);
+  }
+  polygon(points, options) {
+    const o = this._o(options);
+    const paths = [];
+    const outline = linearPath(points, true, o);
+    if (o.fill) {
+      if (o.fillStyle === "solid") {
+        paths.push(solidFillPolygon([points], o));
+      } else {
+        paths.push(patternFillPolygons([points], o));
+      }
+    }
+    if (o.stroke !== NOS) {
+      paths.push(outline);
+    }
+    return this._d("polygon", paths, o);
+  }
+  path(d, options) {
+    const o = this._o(options);
+    const paths = [];
+    if (!d) {
+      return this._d("path", paths, o);
+    }
+    d = (d || "").replace(/\n/g, " ").replace(/(-\s)/g, "-").replace("/(ss)/g", " ");
+    const hasFill = o.fill && o.fill !== "transparent" && o.fill !== NOS;
+    const hasStroke = o.stroke !== NOS;
+    const simplified = !!(o.simplification && o.simplification < 1);
+    const distance2 = simplified ? 4 - 4 * (o.simplification || 1) : (1 + o.roughness) / 2;
+    const sets = pointsOnPath(d, 1, distance2);
+    const shape2 = svgPath(d, o);
+    if (hasFill) {
+      if (o.fillStyle === "solid") {
+        if (sets.length === 1) {
+          const fillShape = svgPath(d, Object.assign(Object.assign({}, o), { disableMultiStroke: true, roughness: o.roughness ? o.roughness + o.fillShapeRoughnessGain : 0 }));
+          paths.push({
+            type: "fillPath",
+            ops: this._mergedShape(fillShape.ops)
+          });
+        } else {
+          paths.push(solidFillPolygon(sets, o));
+        }
+      } else {
+        paths.push(patternFillPolygons(sets, o));
+      }
+    }
+    if (hasStroke) {
+      if (simplified) {
+        sets.forEach((set) => {
+          paths.push(linearPath(set, false, o));
+        });
+      } else {
+        paths.push(shape2);
+      }
+    }
+    return this._d("path", paths, o);
+  }
+  opsToPath(drawing, fixedDecimals) {
+    let path = "";
+    for (const item of drawing.ops) {
+      const data = typeof fixedDecimals === "number" && fixedDecimals >= 0 ? item.data.map((d) => +d.toFixed(fixedDecimals)) : item.data;
+      switch (item.op) {
+        case "move":
+          path += `M${data[0]} ${data[1]} `;
+          break;
+        case "bcurveTo":
+          path += `C${data[0]} ${data[1]}, ${data[2]} ${data[3]}, ${data[4]} ${data[5]} `;
+          break;
+        case "lineTo":
+          path += `L${data[0]} ${data[1]} `;
+          break;
+      }
+    }
+    return path.trim();
+  }
+  toPaths(drawable) {
+    const sets = drawable.sets || [];
+    const o = drawable.options || this.defaultOptions;
+    const paths = [];
+    for (const drawing of sets) {
+      let path = null;
+      switch (drawing.type) {
+        case "path":
+          path = {
+            d: this.opsToPath(drawing),
+            stroke: o.stroke,
+            strokeWidth: o.strokeWidth,
+            fill: NOS
+          };
+          break;
+        case "fillPath":
+          path = {
+            d: this.opsToPath(drawing),
+            stroke: NOS,
+            strokeWidth: 0,
+            fill: o.fill || NOS
+          };
+          break;
+        case "fillSketch":
+          path = this.fillSketch(drawing, o);
+          break;
+      }
+      if (path) {
+        paths.push(path);
+      }
+    }
+    return paths;
+  }
+  fillSketch(drawing, o) {
+    let fweight = o.fillWeight;
+    if (fweight < 0) {
+      fweight = o.strokeWidth / 2;
+    }
+    return {
+      d: this.opsToPath(drawing),
+      stroke: o.fill || NOS,
+      strokeWidth: fweight,
+      fill: NOS
+    };
+  }
+  _mergedShape(input) {
+    return input.filter((d, i) => {
+      if (i === 0) {
+        return true;
+      }
+      if (d.op === "move") {
+        return false;
+      }
+      return true;
+    });
+  }
+};
+
+// ../../node_modules/.pnpm/perfect-freehand@1.2.0/node_modules/perfect-freehand/dist/esm/index.js
+function $(e, t, u, x = (h) => h) {
+  return e * x(0.5 - t * (0.5 - u));
+}
+function se(e) {
+  return [-e[0], -e[1]];
+}
+function l(e, t) {
+  return [e[0] + t[0], e[1] + t[1]];
+}
+function a(e, t) {
+  return [e[0] - t[0], e[1] - t[1]];
+}
+function b(e, t) {
+  return [e[0] * t, e[1] * t];
+}
+function he(e, t) {
+  return [e[0] / t, e[1] / t];
+}
+function R(e) {
+  return [e[1], -e[0]];
+}
+function B(e, t) {
+  return e[0] * t[0] + e[1] * t[1];
+}
+function ue(e, t) {
+  return e[0] === t[0] && e[1] === t[1];
+}
+function ge(e) {
+  return Math.hypot(e[0], e[1]);
+}
+function de(e) {
+  return e[0] * e[0] + e[1] * e[1];
+}
+function A(e, t) {
+  return de(a(e, t));
+}
+function G(e) {
+  return he(e, ge(e));
+}
+function ie(e, t) {
+  return Math.hypot(e[1] - t[1], e[0] - t[0]);
+}
+function L(e, t, u) {
+  let x = Math.sin(u), h = Math.cos(u), y = e[0] - t[0], n = e[1] - t[1], f = y * h - n * x, d = y * x + n * h;
+  return [f + t[0], d + t[1]];
+}
+function K(e, t, u) {
+  return l(e, b(a(t, e), u));
+}
+function ee(e, t, u) {
+  return l(e, b(t, u));
+}
+var { min: C, PI: xe } = Math;
+var pe = 0.275;
+var V = xe + 1e-4;
+function ce(e, t = {}) {
+  let { size: u = 16, smoothing: x = 0.5, thinning: h = 0.5, simulatePressure: y = true, easing: n = (r) => r, start: f = {}, end: d = {}, last: D = false } = t, { cap: S = true, easing: j = (r) => r * (2 - r) } = f, { cap: q = true, easing: c = (r) => --r * r * r + 1 } = d;
+  if (e.length === 0 || u <= 0) return [];
+  let p = e[e.length - 1].runningLength, g = f.taper === false ? 0 : f.taper === true ? Math.max(u, p) : f.taper, T = d.taper === false ? 0 : d.taper === true ? Math.max(u, p) : d.taper, te = Math.pow(u * x, 2), _ = [], M = [], H = e.slice(0, 10).reduce((r, i) => {
+    let o = i.pressure;
+    if (y) {
+      let s = C(1, i.distance / u), W2 = C(1, 1 - s);
+      o = C(1, r + (W2 - r) * (s * pe));
+    }
+    return (r + o) / 2;
+  }, e[0].pressure), m = $(u, h, e[e.length - 1].pressure, n), U, X = e[0].vector, z3 = e[0].point, F = z3, O = z3, E = F, J = false;
+  for (let r = 0; r < e.length; r++) {
+    let { pressure: i } = e[r], { point: o, vector: s, distance: W2, runningLength: I } = e[r];
+    if (r < e.length - 1 && p - I < 3) continue;
+    if (h) {
+      if (y) {
+        let v = C(1, W2 / u), Z = C(1, 1 - v);
+        i = C(1, H + (Z - H) * (v * pe));
+      }
+      m = $(u, h, i, n);
+    } else m = u / 2;
+    U === void 0 && (U = m);
+    let le = I < g ? j(I / g) : 1, fe = p - I < T ? c((p - I) / T) : 1;
+    m = Math.max(0.01, m * Math.min(le, fe));
+    let re = (r < e.length - 1 ? e[r + 1] : e[r]).vector, Y = r < e.length - 1 ? B(s, re) : 1, be = B(s, X) < 0 && !J, ne = Y !== null && Y < 0;
+    if (be || ne) {
+      let v = b(R(X), m);
+      for (let Z = 1 / 13, w = 0; w <= 1; w += Z) O = L(a(o, v), o, V * w), _.push(O), E = L(l(o, v), o, V * -w), M.push(E);
+      z3 = O, F = E, ne && (J = true);
+      continue;
+    }
+    if (J = false, r === e.length - 1) {
+      let v = b(R(s), m);
+      _.push(a(o, v)), M.push(l(o, v));
+      continue;
+    }
+    let oe = b(R(K(re, s, Y)), m);
+    O = a(o, oe), (r <= 1 || A(z3, O) > te) && (_.push(O), z3 = O), E = l(o, oe), (r <= 1 || A(F, E) > te) && (M.push(E), F = E), H = i, X = s;
+  }
+  let P = e[0].point.slice(0, 2), k = e.length > 1 ? e[e.length - 1].point.slice(0, 2) : l(e[0].point, [1, 1]), Q = [], N = [];
+  if (e.length === 1) {
+    if (!(g || T) || D) {
+      let r = ee(P, G(R(a(P, k))), -(U || m)), i = [];
+      for (let o = 1 / 13, s = o; s <= 1; s += o) i.push(L(r, P, V * 2 * s));
+      return i;
+    }
+  } else {
+    if (!(g || T && e.length === 1)) if (S) for (let i = 1 / 13, o = i; o <= 1; o += i) {
+      let s = L(M[0], P, V * o);
+      Q.push(s);
+    }
+    else {
+      let i = a(_[0], M[0]), o = b(i, 0.5), s = b(i, 0.51);
+      Q.push(a(P, o), a(P, s), l(P, s), l(P, o));
+    }
+    let r = R(se(e[e.length - 1].vector));
+    if (T || g && e.length === 1) N.push(k);
+    else if (q) {
+      let i = ee(k, r, m);
+      for (let o = 1 / 29, s = o; s < 1; s += o) N.push(L(i, k, V * 3 * s));
+    } else N.push(l(k, b(r, m)), l(k, b(r, m * 0.99)), a(k, b(r, m * 0.99)), a(k, b(r, m)));
+  }
+  return _.concat(N, M.reverse(), Q);
+}
+function me(e, t = {}) {
+  var q;
+  let { streamline: u = 0.5, size: x = 16, last: h = false } = t;
+  if (e.length === 0) return [];
+  let y = 0.15 + (1 - u) * 0.85, n = Array.isArray(e[0]) ? e : e.map(({ x: c, y: p, pressure: g = 0.5 }) => [c, p, g]);
+  if (n.length === 2) {
+    let c = n[1];
+    n = n.slice(0, -1);
+    for (let p = 1; p < 5; p++) n.push(K(n[0], c, p / 4));
+  }
+  n.length === 1 && (n = [...n, [...l(n[0], [1, 1]), ...n[0].slice(2)]]);
+  let f = [{ point: [n[0][0], n[0][1]], pressure: n[0][2] >= 0 ? n[0][2] : 0.25, vector: [1, 1], distance: 0, runningLength: 0 }], d = false, D = 0, S = f[0], j = n.length - 1;
+  for (let c = 1; c < n.length; c++) {
+    let p = h && c === j ? n[c].slice(0, 2) : K(S.point, n[c], y);
+    if (ue(S.point, p)) continue;
+    let g = ie(p, S.point);
+    if (D += g, c < j && !d) {
+      if (D < x) continue;
+      d = true;
+    }
+    S = { point: p, pressure: n[c][2] >= 0 ? n[c][2] : 0.5, vector: G(a(S.point, p)), distance: g, runningLength: D }, f.push(S);
+  }
+  return f[0].vector = ((q = f[1]) == null ? void 0 : q.vector) || [0, 0], f;
+}
+function ae(e, t = {}) {
+  return ce(me(e, t), t);
+}
+
+// ../diagram/src/export/svg.ts
+var FONT_FAMILY = {
+  1: "Virgil",
+  2: "Helvetica",
+  3: "Cascadia",
+  5: "Excalifont",
+  6: "Nunito",
+  7: "Lilita One",
+  8: "Comic Shanns",
+  9: "Liberation Sans"
+};
+var METRICS = {
+  1: { unitsPerEm: 1e3, ascender: 886, descender: -374 },
+  2: { unitsPerEm: 2048, ascender: 1577, descender: -471 },
+  3: { unitsPerEm: 2048, ascender: 1900, descender: -480 },
+  5: { unitsPerEm: 1e3, ascender: 886, descender: -374 },
+  6: { unitsPerEm: 1e3, ascender: 1011, descender: -353 },
+  7: { unitsPerEm: 1e3, ascender: 923, descender: -220 },
+  8: { unitsPerEm: 1e3, ascender: 750, descender: -250 },
+  9: { unitsPerEm: 2048, ascender: 1854, descender: -434 }
+};
+var fontFamilyCss = (id2) => {
+  const name = FONT_FAMILY[id2];
+  if (!name) return "Segoe UI Emoji";
+  return id2 === 5 ? `${name}, Xiaolai, Segoe UI Emoji` : `${name}, Segoe UI Emoji`;
+};
+function fontsUsed(elements) {
+  const s = /* @__PURE__ */ new Set();
+  for (const e of elements) {
+    if (e.type === "text") s.add(e.fontFamily ?? 5);
+    if (e.type === "frame" || e.type === "magicframe") s.add(2);
+  }
+  return s;
+}
+var DECIMALS = 2;
+var r2 = (n) => Math.round(n * 100) / 100;
+var rotate2 = ([x, y], [cx, cy], a2) => [
+  (x - cx) * Math.cos(a2) - (y - cy) * Math.sin(a2) + cx,
+  (x - cx) * Math.sin(a2) + (y - cy) * Math.cos(a2) + cy
+];
+var isLinear = (e) => e.type === "arrow" || e.type === "line";
+var isFrame = (e) => e.type === "frame" || e.type === "magicframe";
+var isTransparent = (c) => !c || c === "transparent" || c.length === 5 && c.endsWith("0") || c.length === 9 && c.endsWith("00");
+function localBounds(e) {
+  if ((isLinear(e) || e.type === "freedraw") && e.points?.length) {
+    const xs = e.points.map((p) => p[0]);
+    const ys = e.points.map((p) => p[1]);
+    return [Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)];
+  }
+  return [0, 0, e.width, e.height];
+}
+function elementBounds2(e) {
+  const [x1, y1, x2, y2] = localBounds(e);
+  const c = [e.x + (x1 + x2) / 2, e.y + (y1 + y2) / 2];
+  const pts = (isLinear(e) || e.type === "freedraw") && e.points?.length ? e.points.map((p) => [e.x + p[0], e.y + p[1]]) : [
+    [e.x + x1, e.y + y1],
+    [e.x + x2, e.y + y1],
+    [e.x + x2, e.y + y2],
+    [e.x + x1, e.y + y2]
+  ];
+  const r = e.angle ? pts.map((p) => rotate2(p, c, e.angle)) : pts;
+  return [Math.min(...r.map((p) => p[0])), Math.min(...r.map((p) => p[1])), Math.max(...r.map((p) => p[0])), Math.max(...r.map((p) => p[1]))];
+}
+var gen = new RoughGenerator();
+var DEFAULT_PROPORTIONAL_RADIUS = 0.25;
+var DEFAULT_ADAPTIVE_RADIUS = 32;
+function cornerRadius(x, e) {
+  const t = e.roundness?.type;
+  if (t === 2 || t === 1) return x * DEFAULT_PROPORTIONAL_RADIUS;
+  if (t === 3) {
+    const fixed = e.roundness?.value ?? DEFAULT_ADAPTIVE_RADIUS;
+    return x <= fixed / DEFAULT_PROPORTIONAL_RADIUS ? x * DEFAULT_PROPORTIONAL_RADIUS : fixed;
+  }
+  return 0;
+}
+var isPathALoop = (points) => points.length >= 3 && Math.hypot(points[0][0] - points.at(-1)[0], points[0][1] - points.at(-1)[1]) <= 8;
+function adjustRoughness(e) {
+  const max = Math.max(e.width, e.height);
+  const min = Math.min(e.width, e.height);
+  const roundable = e.type === "rectangle" || e.type === "diamond" || isLinear(e);
+  if (min >= 20 && max >= 50 || min >= 15 && !!e.roundness && roundable || isLinear(e) && max >= 50) return e.roughness;
+  return Math.min(e.roughness / (max < 10 ? 3 : 2), 2.5);
+}
+function roughOptions(e, continuousPath = false) {
+  const sw = e.strokeWidth ?? 2;
+  const o = {
+    seed: e.seed,
+    strokeLineDash: e.strokeStyle === "dashed" ? [8, 8 + sw] : e.strokeStyle === "dotted" ? [1.5, 6 + sw] : void 0,
+    disableMultiStroke: e.strokeStyle !== "solid",
+    strokeWidth: e.strokeStyle !== "solid" ? sw + 0.5 : sw,
+    fillWeight: sw / 2,
+    hachureGap: sw * 4,
+    roughness: adjustRoughness(e),
+    stroke: e.strokeColor,
+    preserveVertices: continuousPath || e.roughness < 2,
+    fixedDecimalPlaceDigits: DECIMALS
+  };
+  if (e.type === "rectangle" || e.type === "diamond" || e.type === "ellipse") {
+    o.fillStyle = e.fillStyle;
+    o.fill = isTransparent(e.backgroundColor) ? void 0 : e.backgroundColor;
+    if (e.type === "ellipse") o.curveFitting = 1;
+  } else if ((e.type === "line" || e.type === "freedraw") && isPathALoop(e.points ?? [])) {
+    o.fillStyle = e.fillStyle;
+    o.fill = e.backgroundColor === "transparent" ? void 0 : e.backgroundColor;
+  }
+  return o;
+}
+function diamondPoints(e) {
+  const topX = Math.floor(e.width / 2) + 1;
+  const rightY = Math.floor(e.height / 2) + 1;
+  return [topX, 0, e.width, rightY, topX, e.height, 0, rightY];
+}
+function elbowPath(points, radius) {
+  const sub = [];
+  const horizontal = (a2, b2) => Math.abs(a2[0] - b2[0]) >= Math.abs(a2[1] - b2[1]);
+  for (let i = 1; i < points.length - 1; i++) {
+    const [prev, p, next] = [points[i - 1], points[i], points[i + 1]];
+    const corner = Math.min(radius, Math.hypot(p[0] - next[0], p[1] - next[1]) / 2, Math.hypot(p[0] - prev[0], p[1] - prev[1]) / 2);
+    if (horizontal(p, prev)) sub.push(prev[0] < p[0] ? [p[0] - corner, p[1]] : [p[0] + corner, p[1]]);
+    else sub.push(prev[1] < p[1] ? [p[0], p[1] - corner] : [p[0], p[1] + corner]);
+    sub.push(p);
+    if (horizontal(next, p)) sub.push(next[0] < p[0] ? [p[0] - corner, p[1]] : [p[0] + corner, p[1]]);
+    else sub.push(next[1] < p[1] ? [p[0], p[1] - corner] : [p[0], p[1] + corner]);
+  }
+  const d = [`M ${points[0][0]} ${points[0][1]}`];
+  for (let i = 0; i < sub.length; i += 3) d.push(`L ${sub[i][0]} ${sub[i][1]}`, `Q ${sub[i + 1][0]} ${sub[i + 1][1]}, ${sub[i + 2][0]} ${sub[i + 2][1]}`);
+  d.push(`L ${points.at(-1)[0]} ${points.at(-1)[1]}`);
+  return d.join(" ");
+}
+function arrowheadSize(a2) {
+  if (a2 === "arrow") return 25;
+  if (a2 === "diamond" || a2 === "diamond_outline") return 12;
+  if (a2.startsWith("crowfoot")) return 20;
+  return 15;
+}
+var arrowheadAngle = (a2) => a2 === "bar" ? 90 : a2 === "arrow" ? 20 : 25;
+function curveOps(shape2) {
+  return (shape2.sets.find((s) => s.type === "path") ?? shape2.sets[0]).ops;
+}
+function arrowheadPoints(e, shape2, position, head) {
+  const ops = curveOps(shape2);
+  if (ops.length < 2) return null;
+  const index = position === "start" ? 1 : ops.length - 1;
+  const data = ops[index].data;
+  if (data.length !== 6) return null;
+  const p3 = [data[4], data[5]];
+  const p2 = [data[2], data[3]];
+  const p1 = [data[0], data[1]];
+  const prev = ops[index - 1];
+  let p0 = [0, 0];
+  if (prev.op === "move") p0 = [prev.data[0], prev.data[1]];
+  else if (prev.op === "bcurveTo") p0 = [prev.data[4], prev.data[5]];
+  const eq = (t, i) => (1 - t) ** 3 * p3[i] + 3 * t * (1 - t) ** 2 * p2[i] + 3 * t ** 2 * (1 - t) * p1[i] + p0[i] * t ** 3;
+  const [x2, y2] = position === "start" ? p0 : p3;
+  const [x1, y1] = [eq(0.3, 0), eq(0.3, 1)];
+  const dist = Math.hypot(x2 - x1, y2 - y1);
+  const nx = (x2 - x1) / dist;
+  const ny = (y2 - y1) / dist;
+  const pts = e.points;
+  const [cx, cy] = position === "end" ? pts.at(-1) : pts[0];
+  const [px, py] = pts.length > 1 ? position === "end" ? pts.at(-2) : pts[1] : [0, 0];
+  const length = Math.hypot(cx - px, cy - py);
+  const minSize = Math.min(arrowheadSize(head), length * (head === "diamond" || head === "diamond_outline" ? 0.25 : 0.5));
+  const xs = x2 - nx * minSize;
+  const ys = y2 - ny * minSize;
+  if (head === "dot" || head === "circle" || head === "circle_outline") return [x2, y2, Math.hypot(ys - y2, xs - x2) + (e.strokeWidth ?? 2) - 2];
+  const angle = arrowheadAngle(head) * Math.PI / 180;
+  if (head === "crowfoot_many" || head === "crowfoot_one_or_many") {
+    const [x32, y32] = rotate2([x2, y2], [xs, ys], -angle);
+    const [x42, y42] = rotate2([x2, y2], [xs, ys], angle);
+    return [xs, ys, x32, y32, x42, y42];
+  }
+  const [x3, y3] = rotate2([xs, ys], [x2, y2], -angle);
+  const [x4, y4] = rotate2([xs, ys], [x2, y2], angle);
+  if (head === "diamond" || head === "diamond_outline") {
+    let o;
+    if (position === "start") {
+      const [qx, qy] = pts.length > 1 ? pts[1] : [0, 0];
+      o = rotate2([x2 + minSize * 2, y2], [x2, y2], Math.atan2(qy - y2, qx - x2));
+    } else {
+      const [qx, qy] = pts.length > 1 ? pts.at(-2) : [0, 0];
+      o = rotate2([x2 - minSize * 2, y2], [x2, y2], Math.atan2(y2 - qy, x2 - qx));
+    }
+    return [x2, y2, x3, y3, o[0], o[1], x4, y4];
+  }
+  return [x2, y2, x3, y3, x4, y4];
+}
+function arrowheadShapes(e, shape2, position, head, options, bg) {
+  const pts = arrowheadPoints(e, shape2, position, head);
+  if (!pts) return [];
+  const o = { ...options };
+  switch (head) {
+    case "dot":
+    case "circle":
+    case "circle_outline": {
+      delete o.strokeLineDash;
+      return [gen.circle(pts[0], pts[1], pts[2], { ...o, fill: head === "circle_outline" ? bg : e.strokeColor, fillStyle: "solid", stroke: e.strokeColor, roughness: Math.min(0.5, o.roughness || 0) })];
+    }
+    case "triangle":
+    case "triangle_outline": {
+      delete o.strokeLineDash;
+      const [x, y, x2, y2, x3, y3] = pts;
+      return [gen.polygon([[x, y], [x2, y2], [x3, y3], [x, y]], { ...o, fill: head === "triangle_outline" ? bg : e.strokeColor, fillStyle: "solid", roughness: Math.min(1, o.roughness || 0) })];
+    }
+    case "diamond":
+    case "diamond_outline": {
+      delete o.strokeLineDash;
+      const [x, y, x2, y2, x3, y3, x4, y4] = pts;
+      return [gen.polygon([[x, y], [x2, y2], [x3, y3], [x4, y4], [x, y]], { ...o, fill: head === "diamond_outline" ? bg : e.strokeColor, fillStyle: "solid", roughness: Math.min(1, o.roughness || 0) })];
+    }
+    case "crowfoot_one": {
+      const [, , x3, y3, x4, y4] = pts;
+      return [gen.line(x3, y3, x4, y4, o)];
+    }
+    default: {
+      const [, , x3, y3, x4, y4] = pts;
+      const [x2, y2] = [pts[0], pts[1]];
+      if (e.strokeStyle === "dotted") o.strokeLineDash = [1.5, 6 + (e.strokeWidth ?? 2) - 1 - 1];
+      else delete o.strokeLineDash;
+      o.roughness = Math.min(1, o.roughness || 0);
+      const out = [gen.line(x3, y3, x2, y2, o), gen.line(x4, y4, x2, y2, o)];
+      if (head === "crowfoot_one_or_many") out.push(...arrowheadShapes(e, shape2, position, "crowfoot_one", options, bg));
+      return out;
+    }
+  }
+}
+function shapeOf(e, bg) {
+  switch (e.type) {
+    case "rectangle": {
+      if (e.roundness) {
+        const { width: w, height: h } = e;
+        const r = cornerRadius(Math.min(w, h), e);
+        return [gen.path(`M ${r} 0 L ${w - r} 0 Q ${w} 0, ${w} ${r} L ${w} ${h - r} Q ${w} ${h}, ${w - r} ${h} L ${r} ${h} Q 0 ${h}, 0 ${h - r} L 0 ${r} Q 0 0, ${r} 0`, roughOptions(e, true))];
+      }
+      return [gen.rectangle(0, 0, e.width, e.height, roughOptions(e))];
+    }
+    case "diamond": {
+      const [tX, tY, rX, rY, bX, bY, lX, lY] = diamondPoints(e);
+      if (e.roundness) {
+        const v = cornerRadius(Math.abs(tX - lX), e);
+        const h = cornerRadius(Math.abs(rY - tY), e);
+        return [
+          gen.path(
+            `M ${tX + v} ${tY + h} L ${rX - v} ${rY - h} C ${rX} ${rY}, ${rX} ${rY}, ${rX - v} ${rY + h} L ${bX + v} ${bY - h} C ${bX} ${bY}, ${bX} ${bY}, ${bX - v} ${bY - h} L ${lX + v} ${lY + h} C ${lX} ${lY}, ${lX} ${lY}, ${lX + v} ${lY - h} L ${tX - v} ${tY + h} C ${tX} ${tY}, ${tX} ${tY}, ${tX + v} ${tY + h}`,
+            roughOptions(e, true)
+          )
+        ];
+      }
+      return [gen.polygon([[tX, tY], [rX, rY], [bX, bY], [lX, lY]], roughOptions(e))];
+    }
+    case "ellipse":
+      return [gen.ellipse(e.width / 2, e.height / 2, e.width, e.height, roughOptions(e))];
+    case "line":
+    case "arrow": {
+      const o = roughOptions(e);
+      const points = e.points?.length ? e.points : [[0, 0]];
+      let shapes;
+      if (e.elbowed) shapes = [gen.path(elbowPath(points, 16), roughOptions(e, true))];
+      else if (!e.roundness) shapes = [o.fill ? gen.polygon(points, o) : gen.linearPath(points, o)];
+      else shapes = [gen.curve(points, o)];
+      if (e.type === "arrow" && shapes.length) {
+        const { startArrowhead = null, endArrowhead = "arrow" } = e;
+        if (startArrowhead) shapes.push(...arrowheadShapes(e, shapes[0], "start", startArrowhead, o, bg));
+        if (endArrowhead) shapes.push(...arrowheadShapes(e, shapes[0], "end", endArrowhead, o, bg));
+      }
+      return shapes;
+    }
+    case "freedraw":
+      return isPathALoop(e.points ?? []) ? [gen.curve(e.points, { ...roughOptions(e), stroke: "none" })] : [];
+    default:
+      return [];
+  }
+}
+var esc = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+var attrs = (a2) => Object.entries(a2).filter(([, v]) => v !== void 0 && v !== null && v !== "").map(([k, v]) => ` ${k}="${esc(String(v))}"`).join("");
+function drawableToSvg(d, extra = {}) {
+  const o = d.options;
+  const parts = d.sets.map((set) => {
+    const path = gen.opsToPath(set, DECIMALS);
+    if (set.type === "path")
+      return `<path${attrs({ d: path, stroke: o.stroke, "stroke-width": o.strokeWidth, fill: "none", "stroke-dasharray": o.strokeLineDash?.join(" ") })}/>`;
+    if (set.type === "fillPath")
+      return `<path${attrs({ d: path, stroke: "none", "stroke-width": 0, fill: o.fill, "fill-rule": d.shape === "curve" || d.shape === "polygon" ? "evenodd" : void 0 })}/>`;
+    const fw = o.fillWeight < 0 ? o.strokeWidth / 2 : o.fillWeight;
+    return `<path${attrs({ d: path, stroke: o.fill, "stroke-width": fw, fill: "none", "stroke-dasharray": o.fillLineDash?.join(" ") })}/>`;
+  });
+  return `<g${attrs(extra)}>${parts.join("")}</g>`;
+}
+function freedrawPath(e) {
+  const pts = e.simulatePressure ? e.points : e.points?.length ? e.points.map(([x, y], i) => [x, y, e.pressures?.[i] ?? 0.5]) : [[0, 0, 0.5]];
+  const outline = ae(pts, {
+    simulatePressure: e.simulatePressure,
+    size: (e.strokeWidth ?? 2) * 4.25,
+    thinning: 0.6,
+    smoothing: 0.5,
+    streamline: 0.5,
+    easing: (t) => Math.sin(t * Math.PI / 2),
+    last: !!e.lastCommittedPoint
+  });
+  if (!outline.length) return "";
+  const med = (a2, b2) => [(a2[0] + b2[0]) / 2, (a2[1] + b2[1]) / 2];
+  const d = ["M", outline[0], "Q"];
+  outline.forEach((p, i) => {
+    if (i === outline.length - 1) d.push(p, med(p, outline[0]), "L", outline[0], "Z");
+    else d.push(p, med(p, outline[i + 1]));
+  });
+  return d.map((x) => typeof x === "string" ? x : `${r2(x[0])},${r2(x[1])}`).join(" ");
+}
+var RTL = /[֐-߿יִ-﷽ﹰ-ﻼ]/;
+function textSvg(e, transform, opacity) {
+  const lines = String(e.text ?? "").replace(/\r\n?/g, "\n").split("\n");
+  const lineHeightPx = e.fontSize * (e.lineHeight ?? 1.25);
+  const m = METRICS[e.fontFamily] ?? METRICS[1];
+  const em = e.fontSize / m.unitsPerEm;
+  const verticalOffset = em * m.ascender + (lineHeightPx - em * m.ascender + em * m.descender) / 2;
+  const hOffset = e.textAlign === "center" ? e.width / 2 : e.textAlign === "right" ? e.width : 0;
+  const direction = RTL.test(e.text ?? "") ? "rtl" : "ltr";
+  const anchor = e.textAlign === "center" ? "middle" : e.textAlign === "right" || direction === "rtl" ? "end" : "start";
+  const body = lines.map(
+    (l2, i) => `<text${attrs({
+      x: r2(hOffset),
+      y: r2(i * lineHeightPx + verticalOffset),
+      "font-family": fontFamilyCss(e.fontFamily),
+      "font-size": `${e.fontSize}px`,
+      fill: e.strokeColor,
+      "text-anchor": anchor,
+      style: "white-space: pre;",
+      direction,
+      "dominant-baseline": "alphabetic"
+    })}>${esc(l2)}</text>`
+  ).join("");
+  return `<g${attrs({ transform, "stroke-opacity": opacity !== 1 ? opacity : void 0, "fill-opacity": opacity !== 1 ? opacity : void 0 })}>${body}</g>`;
+}
+function frameLabel(f) {
+  const fontSize = 14;
+  const height = fontSize * 1.25;
+  const name = f.name ?? (f.type === "magicframe" ? "AI Frame" : "Frame");
+  const maxChars = Math.max(1, Math.floor(f.width / (fontSize * 0.55)));
+  const text2 = name.length > maxChars ? `${name.slice(0, Math.max(1, maxChars - 1))}\u2026` : name;
+  return {
+    id: `${f.id}.label`,
+    type: "text",
+    x: f.x,
+    y: f.y - 3 - height,
+    width: Math.min(f.width, text2.length * fontSize * 0.55),
+    height,
+    angle: 0,
+    text: text2,
+    fontSize,
+    fontFamily: 2,
+    lineHeight: 1.25,
+    textAlign: "left",
+    strokeColor: "#999999",
+    opacity: 100,
+    version: 1,
+    versionNonce: 0,
+    isDeleted: false
+  };
+}
+function exportSvg(input, files, opts = {}) {
+  const bgColor = opts.backgroundColor ?? "#ffffff";
+  const padding = opts.padding ?? 10;
+  const live = input.filter((e) => !e.isDeleted).map((e, i) => ({ e, i })).sort((a2, b2) => a2.e.index && b2.e.index ? a2.e.index < b2.e.index ? -1 : a2.e.index > b2.e.index ? 1 : 0 : a2.i - b2.i).map((x) => x.e);
+  const byId = new Map(live.map((e) => [e.id, e]));
+  const frames = live.filter(isFrame);
+  const elements = [];
+  for (const e of live) {
+    if (isFrame(e)) elements.push(frameLabel(e));
+    elements.push(e);
+  }
+  const roots = elements.filter((e) => isFrame(e) || !e.frameId || !byId.has(e.frameId));
+  let [minX, minY, maxX, maxY] = [Infinity, Infinity, -Infinity, -Infinity];
+  for (const e of roots) {
+    const [a2, b2, c, d] = elementBounds2(e);
+    minX = Math.min(minX, a2);
+    minY = Math.min(minY, b2);
+    maxX = Math.max(maxX, c);
+    maxY = Math.max(maxY, d);
+  }
+  if (!Number.isFinite(minX)) [minX, minY, maxX, maxY] = [0, 0, 0, 0];
+  const width = maxX - minX + padding * 2;
+  const height = maxY - minY + padding * 2;
+  const ox = -minX + padding;
+  const oy = -minY + padding;
+  const scale = opts.scale ?? 1;
+  const defs = [];
+  const body = [];
+  const clipIds = /* @__PURE__ */ new Map();
+  frames.forEach((f, i) => {
+    const id2 = `frame-clip-${i}`;
+    clipIds.set(f.id, id2);
+    const [x1, , x2] = localBounds(f);
+    const cx = (x2 - x1) / 2;
+    const cy = f.height / 2;
+    defs.push(`<clipPath id="${id2}"><rect${attrs({ transform: `translate(${r2(f.x + ox)} ${r2(f.y + oy)}) rotate(${f.angle ?? 0} ${cx} ${cy})`, width: f.width, height: f.height, rx: 8, ry: 8 })}/></clipPath>`);
+  });
+  const clip = (e, svg2) => {
+    const id2 = e.frameId && clipIds.get(e.frameId);
+    return id2 ? `<g clip-path="url(#${id2})">${svg2}</g>` : svg2;
+  };
+  const imageSymbols = /* @__PURE__ */ new Set();
+  const render = (e) => {
+    const [x1, y1, x2, y2] = localBounds(e);
+    const cx = (x2 - x1) / 2 + x1;
+    const cy = (y2 - y1) / 2 + y1;
+    const deg = 180 * (e.angle ?? 0) / Math.PI;
+    let tx = e.x + ox;
+    let ty = e.y + oy;
+    const frame2 = e.frameId ? byId.get(e.frameId) : void 0;
+    const opacity = (frame2?.opacity ?? 100) * (e.opacity ?? 100) / 1e4;
+    const op = opacity !== 1 ? { "stroke-opacity": opacity, "fill-opacity": opacity } : {};
+    const transform = () => `translate(${r2(tx)} ${r2(ty)}) rotate(${r2(deg)} ${r2(cx)} ${r2(cy)})`;
+    switch (e.type) {
+      case "rectangle":
+      case "diamond":
+      case "ellipse": {
+        const [shape2] = shapeOf(e, bgColor);
+        body.push(clip(e, drawableToSvg(shape2, { ...op, "stroke-linecap": "round", transform: transform() })));
+        return;
+      }
+      case "line":
+      case "arrow": {
+        const label2 = e.boundElements?.find((b2) => b2.type === "text");
+        const t = label2 && byId.get(label2.id);
+        let mask = "";
+        if (t) {
+          mask = `<mask id="mask-${esc(e.id)}"><rect x="0" y="0" fill="#fff" width="${r2(e.width + 100 + tx)}" height="${r2(e.height + 100 + ty)}"/><rect fill="#000" x="${r2(tx + t.x - e.x)}" y="${r2(ty + t.y - e.y)}" width="${r2(t.width)}" height="${r2(t.height)}" opacity="1"/></mask>`;
+        }
+        const loopFill = e.type === "line" && isPathALoop(e.points ?? []) && e.backgroundColor !== "transparent" ? { "fill-rule": "evenodd" } : {};
+        const g = shapeOf(e, bgColor).map((s) => drawableToSvg(s, { ...op, ...loopFill, transform: transform() })).join("");
+        body.push(clip(e, `<g${attrs({ mask: t ? `url(#mask-${e.id})` : void 0, "stroke-linecap": "round" })}>${g}</g>${mask}`));
+        return;
+      }
+      case "freedraw": {
+        const [fill2] = shapeOf(e, bgColor);
+        const path = `<path fill="${esc(e.strokeColor)}" d="${freedrawPath(e)}"/>`;
+        const inner = fill2 ? drawableToSvg(fill2).replace(/<\/g>$/, `${path}</g>`) : `<g>${path}</g>`;
+        body.push(clip(e, inner.replace(/^<g/, `<g${attrs({ ...op, transform: transform(), stroke: "none" })}`)));
+        return;
+      }
+      case "image": {
+        const file = e.fileId && files[e.fileId];
+        if (!file) return;
+        const symbolId = `image-${file.id}`;
+        if (!imageSymbols.has(symbolId)) {
+          imageSymbols.add(symbolId);
+          defs.unshift(`<symbol id="${esc(symbolId)}"><image href="${esc(file.dataURL)}" preserveAspectRatio="none" width="100%" height="100%"/></symbol>`);
+        }
+        const flip = e.scale && (e.scale[0] !== 1 || e.scale[1] !== 1) ? `translate(${cx} ${cy}) scale(${e.scale[0]} ${e.scale[1]}) translate(${-cx} ${-cy})` : void 0;
+        let g = `<g${attrs({ transform: transform() })}><use${attrs({ href: `#${symbolId}`, width: Math.round(e.width), height: Math.round(e.height), opacity, transform: flip })}/></g>`;
+        if (e.roundness) {
+          const r = cornerRadius(Math.min(e.width, e.height), e);
+          const id2 = `image-clip-${esc(e.id)}`;
+          defs.push(`<clipPath id="${id2}"><rect width="${e.width}" height="${e.height}" rx="${r}" ry="${r}"/></clipPath>`);
+          g = g.replace(/^<g/, `<g clip-path="url(#${id2})"`);
+        }
+        body.push(clip(e, g));
+        return;
+      }
+      case "frame":
+      case "magicframe":
+        body.push(`<rect${attrs({ transform: transform(), width: `${e.width}px`, height: `${e.height}px`, rx: 8, ry: 8, fill: "none", stroke: "#bbb", "stroke-width": 2 })}/>`);
+        return;
+      case "text": {
+        body.push(clip(e, textSvg(e, transform(), opacity)));
+        return;
+      }
+      default: {
+        if (e.type === "embeddable" || e.type === "iframe") {
+          body.push(`<rect${attrs({ transform: transform(), width: e.width, height: e.height, fill: "#d3d3d3", stroke: "#bbb" })}/>`);
+        }
+      }
+    }
+  };
+  for (const e of elements) {
+    if (e.type === "text" && e.containerId && byId.has(e.containerId)) continue;
+    render(e);
+    const label2 = e.boundElements?.find((b2) => b2.type === "text");
+    const t = label2 && byId.get(label2.id);
+    if (t) render(t);
+  }
+  const style = opts.fontCss ? `<style class="style-fonts">${opts.fontCss}</style>` : "";
+  const bg = opts.background !== false ? `<rect x="0" y="0" width="${r2(width)}" height="${r2(height)}" fill="${esc(bgColor)}"/>` : "";
+  const svg = `<svg version="1.1" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${r2(width)} ${r2(height)}" width="${r2(width * scale)}" height="${r2(height * scale)}"><!-- svg-source:vizo --><defs>${defs.join("")}${style}</defs>${bg}${body.join("")}</svg>`;
+  return { svg, width, height };
+}
+
+// src/ttf.ts
+import { readFileSync } from "node:fs";
+function loadFace(path) {
+  const b2 = readFileSync(path);
+  const tables = /* @__PURE__ */ new Map();
+  for (let i = 0; i < b2.readUInt16BE(4); i++) tables.set(b2.toString("latin1", 12 + i * 16, 16 + i * 16), b2.readUInt32BE(12 + i * 16 + 8));
+  const head = tables.get("head");
+  const unitsPerEm = b2.readUInt16BE(head + 18);
+  const numberOfHMetrics = b2.readUInt16BE(tables.get("hhea") + 34);
+  const hmtx = tables.get("hmtx");
+  const glyphOf = cmap(b2, tables.get("cmap"));
+  const width = (g) => b2.readUInt16BE(hmtx + Math.min(g, numberOfHMetrics - 1) * 4);
+  return {
+    has: (cp) => glyphOf(cp) > 0,
+    advance: (cp) => width(glyphOf(cp)) / unitsPerEm
+  };
+}
+function cmap(b2, at) {
+  let f4 = -1;
+  let f12 = -1;
+  for (let i = 0; i < b2.readUInt16BE(at + 2); i++) {
+    const r = at + 4 + i * 8;
+    const [platform, encoding] = [b2.readUInt16BE(r), b2.readUInt16BE(r + 2)];
+    if (!(platform === 0 || platform === 3 && (encoding === 1 || encoding === 10))) continue;
+    const sub = at + b2.readUInt32BE(r + 4);
+    const format = b2.readUInt16BE(sub);
+    if (format === 12) f12 = sub;
+    else if (format === 4) f4 = sub;
+  }
+  if (f12 >= 0) {
+    const n = b2.readUInt32BE(f12 + 12);
+    return (cp) => {
+      let [lo, hi] = [0, n - 1];
+      while (lo <= hi) {
+        const mid = lo + hi >> 1;
+        const g = f12 + 16 + mid * 12;
+        const [start, end] = [b2.readUInt32BE(g), b2.readUInt32BE(g + 4)];
+        if (cp < start) hi = mid - 1;
+        else if (cp > end) lo = mid + 1;
+        else return b2.readUInt32BE(g + 8) + cp - start;
+      }
+      return 0;
+    };
+  }
+  if (f4 < 0) return () => 0;
+  const segX2 = b2.readUInt16BE(f4 + 6);
+  const ends = f4 + 14;
+  const starts = ends + segX2 + 2;
+  const deltas = starts + segX2;
+  const offsets = deltas + segX2;
+  return (cp) => {
+    if (cp > 65535) return 0;
+    for (let i = 0; i < segX2; i += 2) {
+      if (cp > b2.readUInt16BE(ends + i)) continue;
+      const start = b2.readUInt16BE(starts + i);
+      if (cp < start) return 0;
+      const delta = b2.readInt16BE(deltas + i);
+      const ro = b2.readUInt16BE(offsets + i);
+      if (!ro) return cp + delta & 65535;
+      const g = b2.readUInt16BE(offsets + i + ro + (cp - start) * 2);
+      return g ? g + delta & 65535 : 0;
+    }
+    return 0;
+  };
+}
+
+// src/export.ts
+var EXPORT_TOOL = {
+  name: "export_image",
+  title: "Export image",
+  description: "Save a board, or some of its diagrams/elements, as a PNG or SVG file on this machine, drawn the way the board shows it (hand-drawn strokes, fonts, images). Returns the file path, and by default a small preview image so you can check the result.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      boardId: { type: "string", description: "Board id (e.g. 'b_xxx') or full board URL" },
+      format: { type: "string", enum: ["png", "svg"], description: "Default png" },
+      diagramIds: { type: "array", items: { type: "string" }, description: "Only these diagrams (ids from get_board), with their frame and title" },
+      elementIds: { type: "array", items: { type: "string" }, description: "Only these elements; a frame brings its contents, a shape its label" },
+      scale: { type: "number", minimum: 0.1, maximum: 8, description: "PNG pixels per board unit (default 2 = sharp on high-DPI screens)" },
+      background: { type: "boolean", description: "Fill with the board background (default true); false gives a transparent PNG/SVG" },
+      path: { type: "string", description: "Output file. Default: <board title>.<format> in the current directory (never overwrites; adds -2, -3\u2026)" },
+      preview: { type: "boolean", description: "Also return a small PNG preview to look at (default true)" }
+    },
+    required: ["boardId"],
+    additionalProperties: false
+  },
+  annotations: { readOnlyHint: false, destructiveHint: false }
+};
+var MAX_SIDE = 16384;
+var MAX_AREA = 16384 * 16384;
+var PREVIEW_MAX_SIDE = 1200;
+var ExportError = class extends Error {
+};
+function pickElements(scene, args) {
+  const all = scene.elements.filter((e) => !e.isDeleted);
+  if (!args.diagramIds?.length && !args.elementIds?.length) return all;
+  const byId = new Map(all.map((e) => [e.id, e]));
+  const want = /* @__PURE__ */ new Set();
+  const unknown = [];
+  for (const d of args.diagramIds ?? []) {
+    const diagram = scene.diagrams.find((x) => x.id === d);
+    if (diagram && byId.has(diagram.frameElementId)) want.add(diagram.frameElementId);
+    else unknown.push(`diagram '${d}'`);
+  }
+  for (const id2 of args.elementIds ?? []) {
+    if (byId.has(id2)) want.add(id2);
+    else unknown.push(`element '${id2}'`);
+  }
+  if (unknown.length) throw new ExportError(`Not on this board: ${unknown.join(", ")}. Use get_board for ids.`);
+  for (const e of all) if (e.frameId && want.has(e.frameId)) want.add(e.id);
+  for (const e of all) if (e.type === "text" && e.containerId && want.has(e.containerId)) want.add(e.id);
+  return all.filter((e) => want.has(e.id));
+}
+var FONT_DIR = new URL("./fonts/", import.meta.url);
+var manifest = null;
+var fonts = () => manifest ??= JSON.parse(readFileSync2(new URL("fonts.json", FONT_DIR), "utf8"));
+function inRange(range, cp) {
+  if (!range) return true;
+  return range.split(",").some((r) => {
+    const [a2, b2] = r.trim().replace(/^U\+/i, "").split("-");
+    const lo = parseInt(a2, 16);
+    return cp >= lo && cp <= (b2 ? parseInt(b2, 16) : lo);
+  });
+}
+function fontCss(elements) {
+  const used = fontsUsed(elements);
+  const chars = /* @__PURE__ */ new Map();
+  for (const e of elements) {
+    const id2 = e.type === "text" ? e.fontFamily ?? 5 : e.type === "frame" || e.type === "magicframe" ? 2 : null;
+    if (id2 === null) continue;
+    const set = chars.get(id2) ?? /* @__PURE__ */ new Set();
+    for (const ch of String(e.type === "text" ? e.text : e.name ?? "Frame")) set.add(ch.codePointAt(0));
+    chars.set(id2, set);
+  }
+  return fonts().filter((f) => used.has(f.id) && [...chars.get(f.id) ?? []].some((cp) => inRange(f.unicodeRange, cp))).map((f) => {
+    const data = readFileSync2(new URL(f.file, FONT_DIR)).toString("base64");
+    return `@font-face { font-family: "${f.family}"; src: url(data:font/woff2;base64,${data}); ${f.unicodeRange ? `unicode-range: ${f.unicodeRange}; ` : ""}}`;
+  }).join("\n");
+}
+var unescapeXml = (s) => s.replace(/&(lt|gt|quot|amp);/g, (_, e) => ({ lt: "<", gt: ">", quot: '"', amp: "&" })[e]);
+var escapeXml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+var BORROW_ORDER = ["Virgil", "Excalifont", "Comic Shanns", "Liberation Sans", "Nunito", "Cascadia", "Lilita One"];
+var ttfPath = (f) => fileURLToPath(new URL(f.file.replace(/\.woff2$/, ".ttf"), FONT_DIR));
+var faces = /* @__PURE__ */ new Map();
+var face = (f) => faces.get(f.file) ?? faces.set(f.file, loadFace(ttfPath(f))).get(f.file);
+function fontFor(family, cp) {
+  const own = fonts().filter((f) => f.family === family);
+  const others = fonts().filter((f) => f.family !== family).sort((a2, b2) => BORROW_ORDER.indexOf(a2.family) - BORROW_ORDER.indexOf(b2.family));
+  return [...own, ...others].find((f) => face(f).has(cp)) ?? null;
+}
+function guessAdvance(cp) {
+  if (cp === 8205 || cp >= 65024 && cp <= 65039) return 0;
+  const wide = cp >= 4352 && cp <= 4447 || cp >= 11904 && cp <= 42191 || cp >= 44032 && cp <= 55203 || cp >= 63744 && cp <= 64255 || cp >= 65280 && cp <= 65376 || cp >= 126976;
+  return wide ? 1 : 0.8;
+}
+var setAttr = (attrs2, name, value) => new RegExp(` ${name}="[^"]*"`).test(attrs2) ? attrs2.replace(new RegExp(` ${name}="[^"]*"`), ` ${name}="${value}"`) : `${attrs2} ${name}="${value}"`;
+var EMOJI = new RegExp("\\p{Extended_Pictographic}", "u");
+function useTtfFamilies(svg) {
+  return svg.replace(/<text([^>]*?) font-family="([^"]*)"([^>]*)>([^<]*)<\/text>/g, (_, pre, list, post, body) => {
+    let family = list.split(",")[0].trim();
+    if (family === "Helvetica") family = "Liberation Sans";
+    const attrs2 = `${pre}${post} xml:space="preserve"`;
+    const runs = [];
+    for (const ch of unescapeXml(body)) {
+      const cp = ch.codePointAt(0);
+      const last = runs.at(-1);
+      const joiner = cp === 8205 || cp >= 65024 && cp <= 65039 || cp >= 127995 && cp <= 127999;
+      if (last && (ch === " " || joiner)) {
+        last.text += ch;
+        continue;
+      }
+      const emoji = EMOJI.test(ch) && cp > 255;
+      const font = emoji ? null : fontFor(family, cp);
+      if (last && last.font === font && last.emoji === emoji) last.text += ch;
+      else runs.push({ font, emoji, text: ch });
+    }
+    const fontName = (r) => r.font?.ttfFamily ?? family;
+    if (runs.length === 1 && !runs[0].emoji) return `<text${attrs2} font-family="${fontName(runs[0])}">${body}</text>`;
+    if (!runs.length || / direction="rtl"/.test(attrs2)) return `<text${attrs2} font-family="${family}">${body}</text>`;
+    const size = parseFloat(/font-size="([\d.]+)/.exec(attrs2)?.[1] ?? "20");
+    const x = parseFloat(/ x="([-\d.]+)"/.exec(attrs2)?.[1] ?? "0");
+    const anchor = / text-anchor="(\w+)"/.exec(attrs2)?.[1] ?? "start";
+    const widths = runs.map((r) => [...r.text].reduce((w, ch) => w + (r.font ? face(r.font).advance(ch.codePointAt(0)) : guessAdvance(ch.codePointAt(0))), 0) * size);
+    const total = widths.reduce((a2, b2) => a2 + b2, 0);
+    let at = anchor === "middle" ? x - total / 2 : anchor === "end" ? x - total : x;
+    return runs.map((r, i) => {
+      const a2 = setAttr(setAttr(attrs2, "x", Math.round(at * 100) / 100), "text-anchor", "start");
+      at += widths[i];
+      return r.emoji ? "" : `<text${a2} font-family="${fontName(r)}">${escapeXml(r.text)}</text>`;
+    }).join("");
+  });
+}
+async function rasterize(svg, width) {
+  const { Resvg } = await import("@resvg/resvg-js");
+  svg = useTtfFamilies(svg);
+  const fontFiles = fonts().map(ttfPath);
+  const png = new Resvg(svg, {
+    fitTo: { mode: "width", value: Math.max(1, Math.round(width)) },
+    // System fonts cover what Excalidraw's own fonts don't (CJK, emoji); Helvetica falls back to Liberation Sans.
+    font: { fontFiles, loadSystemFonts: true, defaultFontFamily: "Liberation Sans", sansSerifFamily: "Liberation Sans" },
+    imageRendering: 0,
+    shapeRendering: 2,
+    textRendering: 1
+  }).render();
+  return { data: png.asPng(), width: png.width, height: png.height };
+}
+function outputPath(requested, title, format) {
+  if (requested) {
+    const p2 = resolve(requested);
+    return extname(p2).toLowerCase() === `.${format}` ? p2 : `${p2}.${format}`;
+  }
+  const base2 = (title || "board").replace(/[\\/:*?"<>|\x00-\x1f]+/g, "-").trim() || "board";
+  let p = resolve(`${base2}.${format}`);
+  for (let n = 2; existsSync(p); n++) p = resolve(`${base2}-${n}.${format}`);
+  return p;
+}
+async function exportImage(scene, args) {
+  const format = args.format ?? "png";
+  const elements = pickElements(scene, args);
+  if (!elements.length) throw new ExportError("Nothing to export: the board is empty.");
+  const files = Object.fromEntries(scene.files.map((f) => [f.id, f]));
+  const background = args.background !== false;
+  const scale = args.scale ?? 2;
+  const svgOpts = { background, backgroundColor: "#ffffff", fontCss: fontCss(elements) };
+  const { svg, width, height } = exportSvg(elements, files, { ...svgOpts, scale: format === "svg" ? 1 : scale });
+  const path = outputPath(args.path, scene.title ?? "", format);
+  mkdirSync(dirname(path), { recursive: true });
+  let size;
+  let bytes;
+  if (format === "svg") {
+    writeFileSync(path, svg);
+    size = { width: Math.round(width), height: Math.round(height) };
+    bytes = Buffer.byteLength(svg);
+  } else {
+    const w = Math.round(width * scale);
+    const h = Math.round(height * scale);
+    if (w > MAX_SIDE || h > MAX_SIDE || w * h > MAX_AREA)
+      throw new ExportError(`${w}\xD7${h} px is too large (max ${MAX_SIDE} px per side). Use a smaller scale, or export fewer diagrams.`);
+    const png = await rasterize(svg, w);
+    writeFileSync(path, png.data);
+    size = { width: png.width, height: png.height };
+    bytes = png.data.length;
+  }
+  const content = [
+    { type: "text", text: JSON.stringify({ path, format, ...size, bytes, elements: elements.length }, null, 1) }
+  ];
+  if (args.preview !== false) {
+    const fit = Math.min(1, PREVIEW_MAX_SIDE / Math.max(width, height));
+    const preview = await rasterize(svg, width * fit);
+    content.push({ type: "image", data: Buffer.from(preview.data).toString("base64"), mimeType: "image/png" });
+  }
+  return { content };
+}
+
 // src/index.ts
 var PROXY_HEADER = "X-Vizo-Proxy";
 var PUT_TOOL = "put_diagram_elements";
+var SCENE_TOOL = "get_board_scene";
+var HIDDEN = /* @__PURE__ */ new Set([PUT_TOOL, SCENE_TOOL]);
 var LOCAL_TOOLS = /* @__PURE__ */ new Set(["draw_diagram", "update_diagram"]);
 var toolError = (text2) => ({ content: [{ type: "text", text: text2 }], isError: true });
 function arg(name) {
   const i = process.argv.indexOf(`--${name}`);
   if (i >= 0) return process.argv[i + 1];
-  const eq = process.argv.find((a) => a.startsWith(`--${name}=`));
+  const eq = process.argv.find((a2) => a2.startsWith(`--${name}=`));
   return eq?.slice(name.length + 3);
 }
-var log = (...a) => console.error("[vizo-mcp]", ...a);
+var log = (...a2) => console.error("[vizo-mcp]", ...a2);
 async function main() {
   const base2 = (arg("url") ?? process.env.VIZO_URL ?? "").replace(/\/$/, "");
   const token = arg("token") ?? process.env.VIZO_TOKEN;
@@ -1328,32 +4008,38 @@ async function main() {
     process.exit(2);
   }
   const endpoint = new URL(base2.endsWith("/mcp") ? base2 : `${base2}/mcp`);
-  const upstream = new Client({ name: "vizo-mcp-proxy", version: "0.1.0" });
+  const upstream = new Client({ name: "vizo-mcp-proxy", version: "0.2.0" });
   await upstream.connect(
     new StreamableHTTPClientTransport(endpoint, { requestInit: { headers: { Authorization: `Bearer ${token}`, [PROXY_HEADER]: String(LAYOUT_VERSION) } } })
   );
   const caps = upstream.getServerCapabilities() ?? {};
   log(`connected to ${endpoint.href} (local layout v${LAYOUT_VERSION})`);
   const server = new Server(
-    { name: "vizo", version: "0.1.0" },
+    { name: "vizo", version: "0.2.0" },
     {
       capabilities: {
         tools: caps.tools ? {} : void 0,
         resources: caps.resources ? {} : void 0,
         prompts: caps.prompts ? {} : void 0
       },
-      instructions: upstream.getInstructions()
+      instructions: `${upstream.getInstructions() ?? ""}
+
+This local proxy also has export_image: save a board or some of its diagrams as PNG/SVG on this machine (e.g. for docs or a PR), and look at the returned preview to check your drawing.`.trim()
     }
   );
   if (caps.tools) {
     let serverSupportsLocal;
+    let serverSupportsExport = false;
     server.setRequestHandler(ListToolsRequestSchema, async (req) => {
       const r = await upstream.listTools(req.params);
       if (r.tools.some((t) => t.name === PUT_TOOL)) serverSupportsLocal = true;
-      return { ...r, tools: r.tools.filter((t) => t.name !== PUT_TOOL) };
+      serverSupportsExport = r.tools.some((t) => t.name === SCENE_TOOL);
+      const tools = r.tools.filter((t) => !HIDDEN.has(t.name));
+      return { ...r, tools: serverSupportsExport && !r.nextCursor ? [...tools, EXPORT_TOOL] : tools };
     });
     server.setRequestHandler(CallToolRequestSchema, async (req) => {
       const { name, arguments: args = {} } = req.params;
+      if (name === EXPORT_TOOL.name) return exportLocally(args);
       if (!LOCAL_TOOLS.has(name)) return upstream.callTool(req.params);
       serverSupportsLocal ??= (await upstream.listTools()).tools.some((t) => t.name === PUT_TOOL);
       if (!serverSupportsLocal) {
@@ -1398,6 +4084,19 @@ async function main() {
       }
     });
   }
+  async function exportLocally(args) {
+    if (!args?.boardId) return toolError("boardId is required");
+    const r = await upstream.callTool({ name: SCENE_TOOL, arguments: { boardId: args.boardId } });
+    const body = r.content?.find((c) => c.type === "text")?.text ?? "";
+    if (r.isError) return toolError(body || "Couldn't read the board.");
+    try {
+      return await exportImage(JSON.parse(body), args);
+    } catch (e) {
+      if (e instanceof ExportError) return toolError(e.message);
+      log("export failed:", e);
+      return toolError(`Export failed: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
   await server.connect(new StdioServerTransport());
   const shutdown = async () => {
     await Promise.allSettled([server.close(), upstream.close()]);