@graphty/graph-io 0.3.48 → 0.3.50

package/dist/chunks/{styles-yed-Cs1nmrjn.js → styles-yed-XeFBQ6VS.js}

@@ -1,47 +1,9 @@
-import { t as toNeutral, a as toFilePositions } from "./convert-BcQ8_jMo.js";
-import { p as plainCell, n as noteAt, a as STYLE_ISSUE, h as canonNumber, l as canonEnum, g as canonColor, y as colorOpacity, M as MAX_STYLE_VALUE_LENGTH, o as canonText } from "./block-Cu22ewuS.js";
-import { S as StyleApproximations } from "./approximations-C2riR4NT.js";
-const fraction = (v) => String(Math.round(v * 1e4) / 1e4);
-function canonBends(source, target, points, yDown) {
-  const flip = -1;
-  const dx = target[0] - source[0];
-  const dy = (target[1] - source[1]) * flip;
-  const length2 = dx * dx + dy * dy;
-  if (points.length === 0 || length2 <= 0 || !Number.isFinite(length2)) {
-    return null;
-  }
-  const out = [];
-  for (const [px, py] of points) {
-    const rx = px - source[0];
-    const ry = (py - source[1]) * flip;
-    const along = (rx * dx + ry * dy) / length2;
-    const across = (dx * ry - dy * rx) / length2;
-    if (!Number.isFinite(along) || !Number.isFinite(across)) {
-      return null;
-    }
-    out.push(`${fraction(along)},${fraction(across)}`);
-  }
-  return out.join(" ");
-}
-function bendsToPoints(source, target, value, yDown) {
-  const flip = -1;
-  const dx = target[0] - source[0];
-  const dy = (target[1] - source[1]) * flip;
-  const out = [];
-  for (const pair of value.trim().split(/\s+/)) {
-    const [a, c, extra] = pair.split(",").map(Number);
-    if (extra !== void 0 || !Number.isFinite(a) || !Number.isFinite(c)) {
-      return null;
-    }
-    const x = source[0] + a * dx - c * dy;
-    const y = source[1] + (a * dy + c * dx) * flip;
-    if (!Number.isFinite(x) || !Number.isFinite(y)) {
-      return null;
-    }
-    out.push([x, y]);
-  }
-  return out.length === 0 ? null : out;
-}
+import { t as toNeutral, a as toFilePositions } from "./convert-Ct2zelbQ.js";
+import { n as nodeOffsetsToPoints, b as bendsToPoints, f as flattenCubic, a as flattenQuadSpline, c as canonNodeOffsets, d as canonBends } from "./bends-BGXjv_U4.js";
+import { p as plainCell, c as canonNumber, a as canonEnum, n as noteAt, b as STYLE_ISSUE, d as canonColor, e as colorOpacity, M as MAX_STYLE_VALUE_LENGTH, f as canonText, g as canonSigned, h as StyleNotes } from "./block-yl0f_qLO.js";
+import { J as JAVA_MONO, a as JAVA_SERIF, b as JAVA_SANS, j as javaFamily } from "./lexicon-IVRq2Uoo.js";
+import { S as StyleApproximations } from "./approximations-BRXsll0T.js";
+import { e as elementValues, t as takeFromBlock } from "./round-trip-Cy3_SHRZ.js";
 function isTree(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -164,20 +126,120 @@ function activeRealizer(proxy) {
   const active = Number(treeAttr(realizers, "active") ?? "0");
   return all[Number.isInteger(active) && active >= 0 && active < all.length ? active : 0] ?? null;
 }
-const FLOWCHART_SHAPES = /* @__PURE__ */ new Map([
-  ["process", "rectangle"],
-  ["decision", "diamond"],
-  ["terminator", "round-rectangle"],
-  ["start1", "ellipse"],
-  ["start2", "ellipse"],
-  ["data", "parallelogram"],
-  ["preparation", "hexagon"]
+function arcPoints(cx, cy, rx, ry, from, to, steps = 12) {
+  return Array.from({ length: steps + 1 }, (_, i) => {
+    const t = from + (to - from) * i / steps;
+    return pointText(cx + rx * Math.cos(t), cy + ry * Math.sin(t));
+  });
+}
+function wavePoints(y0, amp, x0, x1) {
+  const steps = 16;
+  return Array.from({ length: steps + 1 }, (_, i) => {
+    const x = x0 + (x1 - x0) * i / steps;
+    return pointText(x, y0 + amp * Math.sin(Math.PI * x));
+  });
+}
+function pointText(x, y) {
+  const r = (v) => String(Math.round(v * 1e3) / 1e3 + 0);
+  return `${r(x)},${r(y)}`;
+}
+const HALF_PI = Math.PI / 2;
+const CLOUD = Array.from({ length: 72 }, (_, i) => {
+  const t = 2 * Math.PI * i / 72;
+  const r = 0.86 + 0.14 * Math.abs(Math.cos(4 * t));
+  return pointText(r * Math.cos(t), r * Math.sin(t));
+}).join(" ");
+const STADIUM = [
+  ...arcPoints(0.5, 0, 0.5, 1, -HALF_PI, HALF_PI),
+  ...arcPoints(-0.5, 0, 0.5, 1, HALF_PI, 3 * HALF_PI)
+].join(" ");
+const YED_CONFIGURATIONS = /* @__PURE__ */ new Map([
+  ["flowchart.process", { shape: "rectangle" }],
+  ["flowchart.predefinedprocess", { shape: "rectangle" }],
+  ["flowchart.internalstorage", { shape: "rectangle" }],
+  ["flowchart.decision", { shape: "diamond" }],
+  ["flowchart.terminator", { shape: "round-rectangle" }],
+  ["flowchart.start1", { shape: "ellipse" }],
+  ["flowchart.start2", { shape: "ellipse" }],
+  ["flowchart.onpagereference", { shape: "ellipse" }],
+  ["flowchart.sequentialdata", { shape: "ellipse" }],
+  ["flowchart.data", { shape: "parallelogram" }],
+  ["flowchart.preparation", { shape: "hexagon" }],
+  ["flowchart.database", { shape: "other:database" }],
+  ["flowchart.looplimit", { shape: "polygon", points: "-1,-1 1,-1 1,0.5 0.8,1 -0.8,1 -1,0.5" }],
+  ["flowchart.looplimitend", { shape: "polygon", points: "-1,1 -1,-0.5 -0.8,-1 0.8,-1 1,-0.5 1,1" }],
+  ["flowchart.manualinput", { shape: "polygon", points: "-1,-1 1,-1 1,1 -1,0.4" }],
+  ["flowchart.card", { shape: "polygon", points: "-1,-1 1,-1 1,1 -0.6,1 -1,0.6" }],
+  ["flowchart.manualoperation", { shape: "polygon", points: "-1,1 -0.7,-1 0.7,-1 1,1" }],
+  ["flowchart.offpagereference", { shape: "polygon", points: "-1,1 -1,0 0,-1 1,0 1,1" }],
+  ["flowchart.usermessage", { shape: "polygon", points: "-1,1 -1,-1 0.6,-1 1,0 0.6,1" }],
+  ["flowchart.networkmessage", { shape: "polygon", points: "-1,1 -0.6,0 -1,-1 1,-1 1,1" }],
+  ["flowchart.document", { shape: "polygon", points: ["-1,1", ...wavePoints(-0.75, 0.2, -1, 1), "1,1"].join(" ") }],
+  [
+    "flowchart.papertype",
+    {
+      shape: "polygon",
+      points: [...wavePoints(-0.8, 0.2, -1, 1), ...wavePoints(0.8, 0.2, 1, -1)].join(" ")
+    }
+  ],
+  [
+    "flowchart.delay",
+    { shape: "polygon", points: ["-1,-1", ...arcPoints(0, 0, 1, 1, -HALF_PI, HALF_PI), "-1,1"].join(" ") }
+  ],
+  [
+    "flowchart.display",
+    {
+      shape: "polygon",
+      points: ["-1,0", "-0.6,-1", ...arcPoints(0.6, 0, 0.4, 1, -HALF_PI, HALF_PI), "-0.6,1"].join(" ")
+    }
+  ],
+  [
+    "flowchart.storeddata",
+    {
+      shape: "polygon",
+      points: [
+        ...arcPoints(1, 0, -0.2, 1, -HALF_PI, HALF_PI),
+        ...arcPoints(-0.8, 0, 0.2, 1, HALF_PI, 3 * HALF_PI)
+      ].join(" ")
+    }
+  ],
+  [
+    "flowchart.directdata",
+    {
+      shape: "polygon",
+      points: [
+        ...arcPoints(0.8, 0, 0.2, 1, -HALF_PI, HALF_PI),
+        ...arcPoints(-0.8, 0, 0.2, 1, HALF_PI, 3 * HALF_PI)
+      ].join(" ")
+    }
+  ],
+  ["flowchart.cloud", { shape: "polygon", points: CLOUD }],
+  ["entityrelationship.relationship", { shape: "diamond" }],
+  ["entityrelationship.attribute", { shape: "ellipse" }],
+  ["bpmn.conversation", { shape: "hexagon" }],
+  ["sbgn.unspecifiedentity", { shape: "ellipse" }],
+  ["sbgn.simplechemical", { shape: "ellipse" }],
+  ["sbgn.emptyset", { shape: "ellipse" }],
+  ["sbgn.operator", { shape: "ellipse" }],
+  ["sbgn.macromolecule", { shape: "round-rectangle" }],
+  ["sbgn.phenotype", { shape: "hexagon" }],
+  ["sbgn.process", { shape: "rectangle" }],
+  ["sbgn.submap", { shape: "rectangle" }],
+  ["sbgn.unitofinformation", { shape: "rectangle" }],
+  ["sbgn.statevariable", { shape: "polygon", points: STADIUM }],
+  ["sbgn.tag", { shape: "polygon", points: "-1,1 -1,-1 0.6,-1 1,0 0.6,1" }]
 ]);
-const FLOWCHART_PREFIX = "com.yworks.flowchart.";
-function flowchartShape(configuration) {
-  return configuration.startsWith(FLOWCHART_PREFIX) ? FLOWCHART_SHAPES.get(configuration.slice(FLOWCHART_PREFIX.length)) ?? null : null;
+function configurationOutline(configuration) {
+  const key = configuration.slice(0, MAX_STYLE_VALUE_LENGTH).toLowerCase().replace(/^com\.yworks\./, "").replace(/\.withshadow$/, "");
+  return YED_CONFIGURATIONS.get(key) ?? null;
 }
 const GENERIC_SHAPES = [
+  // yEd's BPMN and entity-relationship palettes: a task is a rounded box, an event a circle, a
+  // gateway a diamond, an attribute an ellipse
+  ["bpmn.activity", "round-rectangle"],
+  ["bpmn.event", "ellipse"],
+  ["bpmn.gateway", "diamond"],
+  ["entityrelationship.attribute", "ellipse"],
   ["ellipse", "ellipse"],
   ["circle", "ellipse"],
   ["oval", "ellipse"],
@@ -226,7 +288,7 @@ function readColor(raw, property, opacity, put, at) {
     put(opacity, alpha);
   }
 }
-function readLabels(labels, node, put, at) {
+function readLabels(labels, node, put, at, geometry) {
   let label = void 0;
   let text = "";
   let extra = 0;
@@ -249,12 +311,20 @@ function readLabels(labels, node, put, at) {
     noteAt(at("label"), STYLE_ISSUE.EXTRA_LABELS, `${String(extra + 1)} labels`);
   }
   put("label", canonText(text, at("label")));
-  readLabelLook(label, node, put, at);
+  readLabelLook(label, node, put, at, geometry);
 }
-function readLabelLook(label, node, put, at) {
+function readLabelLook(label, node, put, at, geometry) {
   readColor(treeAttr(label, "textColor"), "labelColor", null, put, at);
+  if (treeAttr(label, "hasBackgroundColor") !== "false") {
+    readColor(treeAttr(label, "backgroundColor"), "labelBackground", null, put, at);
+  }
+  if (treeAttr(label, "hasLineColor") !== "false" && treeAttr(label, "lineColor") !== void 0) {
+    readColor(treeAttr(label, "lineColor"), "labelBorderColor", null, put, at);
+    put("labelBorderWidth", 1);
+  }
   put("labelSize", canonNumber(treeAttr(label, "fontSize"), at("labelSize")));
-  put("labelFont", canonText(treeAttr(label, "fontFamily"), at("labelFont")));
+  const font = canonText(treeAttr(label, "fontFamily"), at("labelFont"));
+  put("labelFont", font === null ? null : javaFamily(font));
   const style = treeAttr(label, "fontStyle");
   if (style !== void 0) {
     const known = FONT_STYLES.get(style.trim().toLowerCase());
@@ -265,31 +335,101 @@ function readLabelLook(label, node, put, at) {
       put("labelItalic", known[1]);
     }
   }
+  readRotation(label, put, at);
   if (node) {
-    readLabelPosition(label, put, at);
+    const position = nodeLabelPosition(label, geometry, at);
+    put("labelPosition", position);
+    readInsideInset(label, geometry, position, put);
+    readOutsideOffset(label, geometry, position, put);
   }
 }
-function readLabelPosition(label, put, at) {
-  const model = treeAttr(label, "modelName")?.trim().toLowerCase() ?? "internal";
-  if (model === "custom") {
-    const smart = treeChild(treeChild(label, "ModelParameter"), "SmartNodeLabelModelParameter");
-    if (smart === void 0) {
-      noteAt(at("labelPosition"), STYLE_ISSUE.UNKNOWN_VALUE, "custom");
-      return;
+function readRotation(label, put, at) {
+  const angle = canonSigned(treeAttr(label, "rotationAngle"), at("labelRotation"));
+  if (angle === null) {
+    return;
+  }
+  const turn = (angle % 360 + 360) % 360;
+  put("labelRotation", turn === 0 ? null : turn);
+}
+function readOutsideOffset(label, geometry, position, put) {
+  const model = treeAttr(label, "modelName");
+  const free = position === "center" && model !== void 0 && model !== "internal";
+  if (position === null || position.startsWith("inside-") || position === "center" && !free) {
+    return;
+  }
+  if (Number(treeAttr(label, "rotationAngle") ?? 0) % 360 !== 0) {
+    return;
+  }
+  const num = (o, k) => Number(treeAttr(o, k) ?? Number.NaN);
+  const [x, y, w, h] = ["x", "y", "width", "height"].map((k) => num(label, k));
+  const [nw, nh] = [num(geometry, "width"), num(geometry, "height")];
+  if (![x, y, w, h, nw, nh].every(Number.isFinite)) {
+    return;
+  }
+  const signed = (value) => {
+    const r = Math.round(value * 1e3) / 1e3;
+    return r === 0 ? null : r;
+  };
+  const offset = (lo, size, extent, before, after) => {
+    if (before) {
+      return signed(lo + size);
     }
-    put("labelPosition", smartPosition(smart));
+    return after ? signed(lo - extent) : signed(lo + size / 2 - extent / 2);
+  };
+  put("labelOffsetX", offset(x, w, nw, position.includes("left"), position.includes("right")));
+  put("labelOffsetY", offset(y, h, nh, position.includes("top"), position.includes("bottom")));
+}
+function readInsideInset(label, geometry, position, put) {
+  const sized = treeAttr(label, "autoSizePolicy")?.startsWith("node_") === true;
+  if (position?.startsWith("inside-") !== true || sized) {
     return;
   }
+  const num = (o, k) => Number(treeAttr(o, k) ?? Number.NaN);
+  const [x, y, w, h] = ["x", "y", "width", "height"].map((k) => num(label, k));
+  const [nw, nh] = [num(geometry, "width"), num(geometry, "height")];
+  const inset = (value) => Number.isFinite(value) && value > 0 ? Math.round(value * 1e3) / 1e3 : null;
+  if (position.includes("left")) {
+    put("labelOffsetX", inset(x));
+  } else if (position.includes("right")) {
+    const gap = inset(nw - x - w);
+    put("labelOffsetX", gap === null ? null : -gap);
+  }
+  if (position.includes("top")) {
+    put("labelOffsetY", inset(y));
+  } else if (position.includes("bottom")) {
+    const gap = inset(nh - y - h);
+    put("labelOffsetY", gap === null ? null : -gap);
+  }
+}
+function nodeLabelPosition(label, geometry, at) {
+  const outside = boxPosition(label, geometry);
+  if (outside !== null && outside !== "center") {
+    return outside;
+  }
   const position = treeAttr(label, "modelPosition");
-  if (position === void 0) {
-    return;
+  const model = treeAttr(label, "modelName");
+  if (model === "internal") {
+    return insidePosition(label, position);
   }
-  const key = position.trim().toLowerCase();
-  const known = model === "internal" && key === "t" ? "inside-top" : YED_POSITIONS.get(key);
+  if (model === "custom") {
+    return customPosition(label, outside, at);
+  }
+  if (outside !== null || position === void 0) {
+    return outside;
+  }
+  const known = YED_POSITIONS.get(position.trim().toLowerCase());
   if (known === void 0) {
     noteAt(at("labelPosition"), STYLE_ISSUE.UNKNOWN_VALUE, position.slice(0, MAX_STYLE_VALUE_LENGTH));
   }
-  put("labelPosition", known ?? null);
+  return known ?? null;
+}
+function customPosition(label, outside, at) {
+  const smart = treeChild(treeChild(label, "ModelParameter"), "SmartNodeLabelModelParameter");
+  if (smart === void 0) {
+    noteAt(at("labelPosition"), STYLE_ISSUE.UNKNOWN_VALUE, "custom");
+    return outside;
+  }
+  return outside ?? smartPosition(smart);
 }
 function smartPosition(smart) {
   const ratio = (name) => {
@@ -312,6 +452,43 @@ function sideOf(ratio, low, high) {
   }
   return ratio > 0 ? high : "";
 }
+function boxPosition(label, geometry) {
+  const num = (o, k) => Number(treeAttr(o, k) ?? Number.NaN);
+  const [x, y, w, h] = ["x", "y", "width", "height"].map((k) => num(label, k));
+  const [nw, nh] = [num(geometry, "width"), num(geometry, "height")];
+  if (![x, y, w, h, nw, nh].every(Number.isFinite)) {
+    return null;
+  }
+  const side = (lo, size, extent) => {
+    if (lo + size <= 0) {
+      return -1;
+    }
+    return lo >= extent ? 1 : 0;
+  };
+  return BOX_POSITIONS[side(y, h, nh) + 1][side(x, w, nw) + 1];
+}
+function insidePosition(label, position) {
+  const inside = INTERNAL_POSITIONS.get((position ?? "c").trim().toLowerCase()) ?? "center";
+  const align = treeAttr(label, "alignment");
+  const across = treeAttr(label, "autoSizePolicy") === "node_width" && (align === "left" || align === "right");
+  return across && (inside === "inside-top" || inside === "inside-bottom") ? `${inside}-${align}` : inside;
+}
+const INTERNAL_POSITIONS = /* @__PURE__ */ new Map([
+  ["c", "center"],
+  ["t", "inside-top"],
+  ["b", "inside-bottom"],
+  ["l", "inside-left"],
+  ["r", "inside-right"],
+  ["tl", "inside-top-left"],
+  ["tr", "inside-top-right"],
+  ["bl", "inside-bottom-left"],
+  ["br", "inside-bottom-right"]
+]);
+const BOX_POSITIONS = [
+  ["top-left", "top", "top-right"],
+  ["left", "center", "right"],
+  ["bottom-left", "bottom", "bottom-right"]
+];
 function realizerShape(real, at) {
   const shape = treeChild(real.r, "Shape");
   if (shape !== void 0) {
@@ -320,11 +497,14 @@ function realizerShape(real, at) {
   if (real.type === "ShapeNode" || real.type === "GroupNode" || real.type === "GenericGroupNode") {
     return null;
   }
+  if (real.type === "TableNode") {
+    return canonEnum("shape", "rectangle", "yed", at("shape"));
+  }
   if (real.type === "GenericNode") {
     const conf = treeAttr(real.r, "configuration") ?? "";
-    const flowchart = flowchartShape(conf);
-    if (flowchart !== null) {
-      return flowchart;
+    const known = configurationOutline(conf);
+    if (known !== null) {
+      return known.shape;
     }
     const lower = conf.slice(0, MAX_STYLE_VALUE_LENGTH).toLowerCase();
     for (const [word, value] of GENERIC_SHAPES) {
@@ -341,21 +521,102 @@ function realizerShape(real, at) {
   noteAt(at("shape"), STYLE_ISSUE.UNKNOWN_VALUE, real.type);
   return `other:${real.type}`;
 }
-function readNode(real, put, at) {
-  const { r } = real;
-  const fill = treeChild(r, "Fill");
-  if (fill !== void 0) {
-    if (treeAttr(fill, "hasColor") === "false" || treeAttr(fill, "transparent") === "true") {
-      noteAt(at("fill"), STYLE_ISSUE.NO_FILL, "transparent");
-      put("fillOpacity", 0);
-    } else {
-      readColor(treeAttr(fill, "color"), "fill", "fillOpacity", put, at);
-      const second = treeAttr(fill, "color2");
-      if (second !== void 0) {
-        noteAt(at("fill"), STYLE_ISSUE.GRADIENT, second);
+const YED_GRADIENT_ANGLE = 45;
+function readFill(real, put, at) {
+  const fill = treeChild(real.r, "Fill");
+  if (fill === void 0) {
+    return;
+  }
+  if (treeAttr(fill, "hasColor") === "false" || treeAttr(fill, "transparent") === "true") {
+    noteAt(at("fill"), STYLE_ISSUE.NO_FILL, "transparent");
+    put("fillOpacity", 0);
+    return;
+  }
+  readColor(treeAttr(fill, "color"), "fill", "fillOpacity", put, at);
+  const second = canonColor(treeAttr(fill, "color2"), "yed", at("fillGradient"));
+  if (second !== null) {
+    put("fillGradient", second.color);
+    put("fillGradientAngle", YED_GRADIENT_ANGLE);
+  }
+}
+function tableColor(real, name, at) {
+  const props = treeChildren(treeChild(real.r, "StyleProperties"), "Property");
+  const prop = props.find((p) => treeAttr(p, "name") === name);
+  return prop === void 0 ? null : canonColor(treeAttr(prop, "value"), "yed", at("stripeColors"))?.color ?? null;
+}
+function readTable(real, put, at) {
+  const table = treeChild(real.r, "Table");
+  const rows = treeChildren(treeChild(table, "Rows"), "Row");
+  const columns = treeChildren(treeChild(table, "Columns"), "Column");
+  const across = columns.length > 1 && rows.length <= 1;
+  const lanes = (across ? columns : rows).map((l) => Number(treeAttr(l, across ? "width" : "height")));
+  const insets = treeChild(table, "Insets");
+  const inset = (side) => Math.max(0, Number(treeAttr(insets, side) ?? 0) || 0);
+  const [head, tail] = across ? [inset("left"), inset("right")] : [inset("top"), inset("bottom")];
+  const sizes = [head, ...lanes, tail];
+  const total = sizes.reduce((a, b) => a + b, 0);
+  if (lanes.length === 0 || !sizes.every(Number.isFinite) || total <= 0) {
+    return;
+  }
+  const fill = canonColor(treeAttr(treeChild(real.r, "Fill"), "color"), "yed", at("stripeColors"))?.color ?? "#ffffff";
+  const main = tableColor(real, "yed.table.lane.color.main", at) ?? fill;
+  const alternating = tableColor(real, "yed.table.lane.color.alternating", at) ?? main;
+  const header = tableColor(real, "yed.table.header.color.main", at) ?? fill;
+  const bands = [[head, header], ...lanes.map((size, i) => [size, i % 2 === 0 ? main : alternating]), [tail, fill]].filter(([size]) => size > 0);
+  put("stripeColors", bands.map(([, color]) => color).join(" "));
+  put("stripeSizes", bands.map(([size]) => String(Number((size / total).toFixed(6)))).join(" "));
+  if (across) {
+    put("stripeDirection", "right");
+  }
+}
+function yedResources(snapshot) {
+  const out = /* @__PURE__ */ new Map();
+  for (const col of snapshot.graph) {
+    if (col.dtype !== "json" || col.meta.origin?.namespace !== "yfiles") {
+      continue;
+    }
+    addYedResources(plainCell(snapshot.graph.value(col.meta.name, 0)), out);
+  }
+  return out;
+}
+function addYedResources(root, out) {
+  for (const resources of treeChildren(root, "Resources")) {
+    for (const r of treeChildren(resources, "Resource")) {
+      const id = treeAttr(r, "id");
+      const url = id === void 0 || out.has(id) ? null : yedResourceUrl(r);
+      if (id !== void 0 && url !== null) {
+        out.set(id, url);
       }
     }
   }
+}
+function yedResourceUrl(r) {
+  const text = treeText(r)?.trim() ?? "";
+  if (text === "") {
+    return null;
+  }
+  const type = treeAttr(r, "type") ?? "";
+  if (type.endsWith("BufferedImage")) {
+    return `data:image/png;base64,${text.replaceAll(/\s+/g, "")}`;
+  }
+  if (text.includes("<svg")) {
+    return `data:image/svg+xml;utf8,${encodeURIComponent(text)}`;
+  }
+  return null;
+}
+function readPicture(real, resources, put) {
+  const ref = real.type === "ImageNode" ? treeAttr(treeChild(real.r, "Image"), "refid") : treeAttr(treeChild(treeChild(real.r, "SVGModel"), "SVGContent"), "refid");
+  const src = ref === void 0 ? void 0 : resources.get(ref);
+  if (src === void 0) {
+    return;
+  }
+  put("image", src);
+  put("imageFit", "fill");
+  put("imageClip", "none");
+}
+function readNode(real, put, at, resources) {
+  const { r } = real;
+  readFill(real, put, at);
   const border = treeChild(r, "BorderStyle");
   if (border !== void 0) {
     if (treeAttr(border, "hasColor") === "false") {
@@ -370,7 +631,17 @@ function readNode(real, put, at) {
   put("width", canonNumber(treeAttr(geometry, "width"), at("width")));
   put("height", canonNumber(treeAttr(geometry, "height"), at("height")));
   put("shape", realizerShape(real, at));
-  readLabels(treeChildren(r, "NodeLabel"), true, put, at);
+  const points = real.type === "GenericNode" ? configurationOutline(treeAttr(r, "configuration") ?? "")?.points : void 0;
+  if (points !== void 0) {
+    put("shapePoints", points);
+  }
+  if (real.type === "TableNode") {
+    readTable(real, put, at);
+  }
+  if (resources !== void 0 && (real.type === "ImageNode" || real.type === "SVGNode")) {
+    readPicture(real, resources, put);
+  }
+  readLabels(treeChildren(r, "NodeLabel"), true, put, at, geometry);
 }
 function readEdge(real, put, at) {
   const { r } = real;
@@ -386,27 +657,56 @@ function readEdge(real, put, at) {
     put("targetArrow", canonEnum("arrow", treeAttr(arrows, "target"), "yed", at("targetArrow")));
   }
   put("curved", edgeCurved(real));
+  if (real.type === "ArcEdge") {
+    put("bendCurve", "arc");
+  }
   readLabels(treeChildren(r, "EdgeLabel"), false, put, at);
 }
 function edgeCurved(real) {
   if (real.type === "ArcEdge") {
     return true;
   }
-  const bent = treeChildren(treeChild(real.r, "Path"), "Point").length > 0;
-  if (real.type !== "PolyLineEdge") {
+  const points = treeChildren(treeChild(real.r, "Path"), "Point").length;
+  if (real.type === "QuadCurveEdge") {
+    return false;
+  }
+  if (real.type === "BezierEdge") {
+    return points > 0 && (points + 1) % 3 !== 0;
+  }
+  const bent = points > 0;
+  if (real.type !== "PolyLineEdge" && real.type !== "GenericEdge") {
     return bent;
   }
   const smoothed = treeAttr(treeChild(real.r, "BendStyle"), "smoothed");
   return smoothed === void 0 ? null : smoothed === "true" && bent;
 }
-function edgeBends(real, centers, source, target) {
-  const points = treeChildren(treeChild(real.r, "Path"), "Point").map((p) => [
+function readEdgeRoute(real, nodes, source, target, put) {
+  const path = treeChild(real.r, "Path");
+  const at = (k) => [nodes[4 * k], nodes[4 * k + 1]];
+  const size = (k) => [nodes[4 * k + 2], nodes[4 * k + 3]];
+  const offset = (key) => Number(treeAttr(path, key) ?? 0) || 0;
+  const ends = [
+    [at(source)[0] + offset("sx"), at(source)[1] + offset("sy")],
+    [at(target)[0] + offset("tx"), at(target)[1] + offset("ty")]
+  ];
+  const port = (k, end) => end[0] === at(k)[0] && end[1] === at(k)[1] ? null : canonNodeOffsets(at(k), size(k), [end], true);
+  put("sourcePort", port(source, ends[0]));
+  put("targetPort", port(target, ends[1]));
+  let points = treeChildren(path, "Point").map((p) => [
     Number(treeAttr(p, "x")),
     Number(treeAttr(p, "y"))
   ]);
-  const at = (k) => [centers[2 * k], centers[2 * k + 1]];
-  return canonBends(at(source), at(target), points);
+  if (points.length > 0 && (real.type === "BezierEdge" || real.type === "QuadCurveEdge")) {
+    const controls = [ends[0], ...points, ends[1]];
+    const curve = real.type === "BezierEdge" ? flattenCubic(controls) : flattenQuadSpline(controls, Number(treeAttr(real.r, "straightness") ?? YED_STRAIGHTNESS));
+    points = (curve ?? controls).slice(1, -1);
+  }
+  put(
+    "bends",
+    source === target ? canonNodeOffsets(at(source), size(source), points, true) : canonBends(at(source), at(target), points, true)
+  );
 }
+const YED_STRAIGHTNESS = 0.1;
 function valueColumns(n) {
   const values = /* @__PURE__ */ Object.create(null);
   return {
@@ -421,7 +721,8 @@ function valueColumns(n) {
 }
 function readYedStyles(snapshot, notes, budget) {
   let found = false;
-  const centers = new Float64Array(2 * snapshot.nodeCount).fill(Number.NaN);
+  const resources = yedResources(snapshot);
+  const boxes = new Float64Array(4 * snapshot.nodeCount).fill(Number.NaN);
   const read = (target) => {
     const table = target === "node" ? snapshot.nodes : snapshot.edges;
     const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
@@ -446,13 +747,16 @@ function readYedStyles(snapshot, notes, budget) {
         out.put(i, property, value);
       };
       if (target === "node") {
-        readNode(real, put, at);
+        readNode(real, put, at, resources);
         const geometry = treeChild(real.r, "Geometry");
-        centers[2 * i] = Number(treeAttr(geometry, "x")) + Number(treeAttr(geometry, "width")) / 2;
-        centers[2 * i + 1] = Number(treeAttr(geometry, "y")) + Number(treeAttr(geometry, "height")) / 2;
+        const [w, h] = [Number(treeAttr(geometry, "width")), Number(treeAttr(geometry, "height"))];
+        boxes.set(
+          [Number(treeAttr(geometry, "x")) + w / 2, Number(treeAttr(geometry, "y")) + h / 2, w, h],
+          4 * i
+        );
       } else {
         readEdge(real, put, at);
-        put("bends", edgeBends(real, centers, snapshot.edgeSource(i), snapshot.edgeTarget(i)));
+        readEdgeRoute(real, boxes, snapshot.edgeSource(i), snapshot.edgeTarget(i), put);
       }
     }
     return out.values;
@@ -466,6 +770,8 @@ const GRAPHML_STYLE_CAPABILITIES = Object.freeze({
   node: Object.freeze([
     "fill",
     "fillOpacity",
+    "fillGradient",
+    "fillGradientAngle",
     "borderColor",
     "borderWidth",
     "borderStyle",
@@ -489,6 +795,8 @@ const GRAPHML_STYLE_CAPABILITIES = Object.freeze({
     "targetArrow",
     "curved",
     "bends",
+    "sourcePort",
+    "targetPort",
     "label",
     "labelColor",
     "labelSize",
@@ -518,9 +826,9 @@ const YED_LINES = /* @__PURE__ */ new Map([
 ]);
 const YED_ARROWS = /* @__PURE__ */ new Map([
   ["none", "none"],
-  ["triangle", "standard"],
+  ["triangle", "delta"],
   ["triangle-open", "white_delta"],
-  ["vee", "concave"],
+  ["vee", "standard"],
   ["tee", "t_shape"],
   ["diamond", "diamond"],
   ["diamond-open", "white_diamond"],
@@ -529,17 +837,18 @@ const YED_ARROWS = /* @__PURE__ */ new Map([
   ["square", "skewed_dash"],
   ["crow", "crows_foot_many"]
 ]);
+const INTERNAL_MODEL_POSITIONS = new Map(
+  [...INTERNAL_POSITIONS].map(([model, position]) => [position, model])
+);
 const YED_MODEL_POSITIONS = /* @__PURE__ */ new Map([
-  ["center", ["internal", "c"]],
-  ["inside-top", ["internal", "t"]],
-  ["top", ["eight_pos", "n"]],
-  ["bottom", ["eight_pos", "s"]],
-  ["left", ["eight_pos", "w"]],
-  ["right", ["eight_pos", "e"]],
-  ["top-left", ["eight_pos", "nw"]],
-  ["top-right", ["eight_pos", "ne"]],
-  ["bottom-left", ["eight_pos", "sw"]],
-  ["bottom-right", ["eight_pos", "se"]]
+  ["top", "n"],
+  ["bottom", "s"],
+  ["left", "w"],
+  ["right", "e"],
+  ["top-left", "nw"],
+  ["top-right", "ne"],
+  ["bottom-left", "sw"],
+  ["bottom-right", "se"]
 ]);
 function yedValue(table, value, nearest) {
   const exact = table.get(value);
@@ -562,15 +871,19 @@ function yedSpelled(table, value, nearest, property, approximate) {
   }
   return w.value;
 }
-function labelTree(get, node, approximate) {
-  const text = get("label");
-  if (typeof text !== "string" || text.trim().length === 0) {
-    return null;
-  }
+const JAVA_LOGICAL = {
+  [JAVA_SANS]: "Dialog",
+  [JAVA_SERIF]: "Serif",
+  [JAVA_MONO]: "Monospaced"
+};
+function yedFontName(family) {
+  return Object.hasOwn(JAVA_LOGICAL, family) ? JAVA_LOGICAL[family] : family.split(",")[0].trim();
+}
+function labelFontTree(get) {
   const label = {};
   const font = get("labelFont");
   if (typeof font === "string") {
-    label["@_fontFamily"] = font;
+    label["@_fontFamily"] = yedFontName(font);
   }
   const size = get("labelSize");
   if (typeof size === "number") {
@@ -582,18 +895,27 @@ function labelTree(get, node, approximate) {
     const style = (weight === "bold" ? "bold" : "") + (italic === true ? "italic" : "");
     label["@_fontStyle"] = style.length === 0 ? "plain" : style;
   }
+  return label;
+}
+function labelTree(get, node, approximate) {
+  const text = get("label");
+  if (typeof text !== "string" || text.trim().length === 0) {
+    return null;
+  }
+  const label = labelFontTree(get);
   const color = get("labelColor");
   if (typeof color === "string") {
     label["@_textColor"] = color.toUpperCase();
   }
   const position = node ? get("labelPosition") : null;
   if (typeof position === "string") {
-    const written = YED_MODEL_POSITIONS.get(position);
-    if (written === void 0) {
+    const inside = INTERNAL_MODEL_POSITIONS.get(position);
+    const outside = YED_MODEL_POSITIONS.get(position);
+    if (inside === void 0 && outside === void 0) {
       approximate("labelPosition", position);
     }
-    label["@_modelName"] = written?.[0] ?? "internal";
-    label["@_modelPosition"] = written?.[1] ?? "c";
+    label["@_modelName"] = outside === void 0 ? "internal" : "eight_pos";
+    label["@_modelPosition"] = outside ?? inside ?? "c";
   }
   label["#text"] = text;
   return label;
@@ -605,6 +927,14 @@ function shapeNodeTree(get, at, approximate) {
   const fillOpacity = get("fillOpacity");
   if (typeof fill === "string") {
     node["y:Fill"] = { "@_color": yedColor(fill, fillOpacity), "@_transparent": "false" };
+    const second = get("fillGradient");
+    if (typeof second === "string") {
+      node["y:Fill"]["@_color2"] = second.toUpperCase();
+      const angle = get("fillGradientAngle");
+      if (angle !== YED_GRADIENT_ANGLE) {
+        approximate("fillGradientAngle", angle ?? 0);
+      }
+    }
   } else if (fillOpacity === 0) {
     node["y:Fill"] = { "@_hasColor": "false", "@_transparent": "false" };
   }
@@ -673,7 +1003,7 @@ function polyLineEdgeTree(get, path, approximate) {
   const source = get("sourceArrow");
   const target = get("targetArrow");
   if (source !== null || target !== null) {
-    const arrow = (property, value) => typeof value === "string" ? yedSpelled(YED_ARROWS, value, "standard", property, approximate) : "none";
+    const arrow = (property, value) => typeof value === "string" ? yedSpelled(YED_ARROWS, value, "delta", property, approximate) : "none";
     edge["y:Arrows"] = { "@_source": arrow("sourceArrow", source), "@_target": arrow("targetArrow", target) };
   }
   const label = labelTree(get, false, approximate);
@@ -686,33 +1016,17 @@ function polyLineEdgeTree(get, path, approximate) {
   }
   return { "y:PolyLineEdge": edge };
 }
-function getter(picture, target) {
-  const columns = /* @__PURE__ */ new Map();
-  for (const p of GRAPHML_STYLE_CAPABILITIES[target]) {
-    columns.set(p, picture(target, p));
-  }
-  return (i) => (property) => columns.get(property)?.[i] ?? null;
-}
-function exactFromBlock(read, picture, counts, notes) {
-  for (const target of ["node", "edge"]) {
-    const values = read[target];
-    const get = getter(picture, target);
-    for (let i = 0; i < counts[target]; i++) {
-      const want = get(i);
+function exactFromBlock(snapshot, text, read) {
+  const notes = new StyleNotes();
+  takeFromBlock(snapshot, text, "graphml", (target) => ({
+    values: read[target],
+    properties: GRAPHML_STYLE_CAPABILITIES[target],
+    writes: GRAPHML_STYLE_CAPABILITIES[target],
+    readBack: (_i, want) => {
       const back = writtenAndReadBack(target, want, notes);
-      if (back === null) {
-        continue;
-      }
-      for (const property of GRAPHML_STYLE_CAPABILITIES[target]) {
-        const native = values[property]?.[i] ?? null;
-        const w = want(property);
-        if (native !== w && native === (back.get(property) ?? null)) {
-          values[property] ??= new Array(counts[target]).fill(null);
-          values[property][i] = w;
-        }
-      }
+      return back === null ? null : (property) => back.get(property) ?? null;
     }
-  }
+  }));
 }
 function writtenAndReadBack(target, want, notes) {
   const ignore = () => void 0;
@@ -777,16 +1091,29 @@ function keptPath(table, columns, e) {
   }
   return void 0;
 }
-function pathWithBends(kept, bends, ends) {
-  const points = typeof bends === "string" ? bendsToPoints(ends[0], ends[1], bends) : null;
-  if (points === null) {
+function pathWithRoute(kept, get, ends, loop) {
+  const bends = get("bends");
+  const [[c0, size0], [c1]] = ends;
+  let points = null;
+  if (typeof bends === "string") {
+    points = loop ? nodeOffsetsToPoints(c0, size0, bends) : bendsToPoints(c0, c1, bends);
+  }
+  const ports = ["sourcePort", "targetPort"].map((property, k) => {
+    const value = get(property);
+    const [center, size] = ends[k];
+    const at = typeof value === "string" ? nodeOffsetsToPoints(center, size, value) : null;
+    return at === null ? null : [at[0][0] - center[0], at[0][1] - center[1]];
+  });
+  if (points === null && ports.every((p) => p === null)) {
     return kept;
   }
   const path = {};
-  for (const port of ["sx", "sy", "tx", "ty"]) {
-    path[`@_${port}`] = treeAttr(kept, port) ?? "0.0";
-  }
-  path["y:Point"] = points.map(([x, y]) => ({ "@_x": String(x), "@_y": String(y) }));
+  ["sx", "sy", "tx", "ty"].forEach((key, k) => {
+    const port = ports[k >> 1];
+    path[`@_${key}`] = port === null ? treeAttr(kept, key) ?? "0.0" : String(port[k & 1]);
+  });
+  const written = points ?? treeChildren(kept, "Point").map((q) => [Number(treeAttr(q, "x")), Number(treeAttr(q, "y"))]);
+  path["y:Point"] = written.map(([x, y]) => ({ "@_x": String(x), "@_y": String(y) }));
   return path;
 }
 function freeName(table, base) {
@@ -809,27 +1136,32 @@ function graphmlStyledExport(snapshot, input) {
   const picture = (target, property) => input.picture(target, property);
   const nodeColumns = treeColumns(snapshot.nodes);
   const edgeColumns = treeColumns(snapshot.edges);
-  const getNode = getter(picture, "node");
-  const getEdge = getter(picture, "edge");
+  const getNode = elementValues(picture, "node", GRAPHML_STYLE_CAPABILITIES.node);
+  const getEdge = elementValues(picture, "edge", GRAPHML_STYLE_CAPABILITIES.edge);
   const nodeTrees = [];
   for (let i = 0; i < snapshot.nodeCount; i++) {
     const get = getNode(i);
     const at = keptPosition(snapshot.nodes, nodeColumns, i) ?? columnPosition(snapshot, i, get);
     nodeTrees.push(shapeNodeTree(get, at, approximateFor("node")));
   }
-  const centers = nodeTrees.map((tree) => {
+  const boxes = nodeTrees.map((tree) => {
     const geometry = treeChild(treeChild(tree, "ShapeNode"), "Geometry");
     const at = (k) => Number(treeAttr(geometry, k) ?? Number.NaN);
-    return [at("x") + at("width") / 2, at("y") + at("height") / 2];
+    return [
+      [at("x") + at("width") / 2, at("y") + at("height") / 2],
+      [at("width"), at("height")]
+    ];
   });
   const edgeTrees = [];
   for (let e = 0; e < snapshot.edgeCount; e++) {
     const get = getEdge(e);
-    const ends = [
-      centers[snapshot.edgeSource(e)],
-      centers[snapshot.edgeTarget(e)]
-    ];
-    const path = pathWithBends(keptPath(snapshot.edges, edgeColumns, e), get("bends"), ends);
+    const [source, target] = [snapshot.edgeSource(e), snapshot.edgeTarget(e)];
+    const path = pathWithRoute(
+      keptPath(snapshot.edges, edgeColumns, e),
+      get,
+      [boxes[source], boxes[target]],
+      source === target
+    );
     edgeTrees.push(polyLineEdgeTree(get, path, approximateFor("edge")));
   }
   const out = snapshot.withColumns();
@@ -861,22 +1193,21 @@ export {
   YED_SHAPES as Y,
   yedColor as a,
   yedSpelled as b,
-  bendsToPoints as c,
+  yedFontName as c,
   YED_LINES as d,
-  canonBends as e,
-  flowchartShape as f,
-  YED_ARROWS as g,
-  graphmlStyledExport as h,
+  configurationOutline as e,
+  YED_ARROWS as f,
+  graphmlStyledExport as g,
+  treeAttr as h,
   isTree as i,
-  treeAttr as j,
-  treeChild as k,
+  treeChild as j,
+  treeText as k,
   localOf as l,
-  treeText as m,
-  yfilesColumns as n,
-  exactFromBlock as o,
+  yfilesColumns as m,
+  exactFromBlock as n,
   readYedStyles as r,
   treeChildren as t,
   valueColumns as v,
   yedValue as y
 };
-//# sourceMappingURL=styles-yed-Cs1nmrjn.js.map
+//# sourceMappingURL=styles-yed-XeFBQ6VS.js.map