@graphty/graph-io 0.3.43 → 0.3.44

package/dist/chunks/styles-yed-DAfcIkf7.js

@@ -0,0 +1,842 @@
+import { t as toNeutral, a as toFilePositions } from "./convert-BcQ8_jMo.js";
+import { m as plainCell, n as noteAt, a as STYLE_ISSUE, b as canonNumber, f as canonEnum, c as canonColor, o as colorOpacity, M as MAX_STYLE_VALUE_LENGTH, h as canonText } from "./block-JQiwViEt.js";
+import { S as StyleApproximations } from "./approximations-3Q4TsdTh.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;
+}
+function isTree(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function localOf(name) {
+  const colon = name.indexOf(":");
+  return colon < 0 ? name : name.slice(colon + 1);
+}
+function treeChildren(node, local) {
+  const out = [];
+  if (!isTree(node)) {
+    return out;
+  }
+  for (const key of Object.keys(node)) {
+    if (key.startsWith("@_") || key === "#text" || localOf(key) !== local) {
+      continue;
+    }
+    const value = node[key];
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        out.push(item);
+      }
+    } else {
+      out.push(value);
+    }
+  }
+  return out;
+}
+function treeChild(node, local) {
+  if (!isTree(node)) {
+    return void 0;
+  }
+  for (const key of Object.keys(node)) {
+    if (!key.startsWith("@_") && key !== "#text" && localOf(key) === local) {
+      const value = node[key];
+      return Array.isArray(value) ? value[0] : value;
+    }
+  }
+  return void 0;
+}
+function treeAttr(node, name) {
+  if (!isTree(node) || !Object.hasOwn(node, `@_${name}`)) {
+    return void 0;
+  }
+  const value = node[`@_${name}`];
+  return typeof value === "string" ? value : void 0;
+}
+function treeText(node) {
+  if (typeof node === "string") {
+    return node;
+  }
+  if (isTree(node) && Object.hasOwn(node, "#text")) {
+    const text = node["#text"];
+    return typeof text === "string" ? text : null;
+  }
+  return null;
+}
+function treeColumns(table) {
+  const out = [];
+  for (const col of table) {
+    if (col.dtype === "json" && col.meta.origin?.namespace === "yfiles") {
+      out.push(col.meta.name);
+    }
+  }
+  return out;
+}
+function yfilesColumns(table) {
+  const out = [];
+  for (const col of table) {
+    if (col.meta.origin?.namespace === "yfiles") {
+      out.push(col.meta.name);
+    }
+  }
+  return out;
+}
+const NODE_REALIZERS = /* @__PURE__ */ new Set([
+  "ShapeNode",
+  "GenericNode",
+  "GroupNode",
+  "GenericGroupNode",
+  "SVGNode",
+  "ImageNode",
+  "TableNode",
+  "UMLClassNode",
+  "UMLNoteNode",
+  "ProxyAutoBoundsNode"
+]);
+const EDGE_REALIZERS = /* @__PURE__ */ new Set([
+  "PolyLineEdge",
+  "ArcEdge",
+  "BezierEdge",
+  "QuadCurveEdge",
+  "SplineEdge",
+  "GenericEdge"
+]);
+function realizerOf(tree, names) {
+  if (!isTree(tree)) {
+    return null;
+  }
+  for (const key of Object.keys(tree)) {
+    const type = localOf(key);
+    if (key.startsWith("@_") || !names.has(type)) {
+      continue;
+    }
+    const value = tree[key];
+    const r = Array.isArray(value) ? value[0] : value;
+    return type === "ProxyAutoBoundsNode" ? activeRealizer(r) : { type, r };
+  }
+  return null;
+}
+function activeRealizer(proxy) {
+  const realizers = treeChild(proxy, "Realizers");
+  const all = [];
+  if (isTree(realizers)) {
+    for (const k of Object.keys(realizers).filter((key) => !key.startsWith("@_") && key !== "#text")) {
+      for (const item of treeChildren(realizers, localOf(k))) {
+        all.push({ type: localOf(k), r: item });
+      }
+    }
+  }
+  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"]
+]);
+const FLOWCHART_PREFIX = "com.yworks.flowchart.";
+function flowchartShape(configuration) {
+  return configuration.startsWith(FLOWCHART_PREFIX) ? FLOWCHART_SHAPES.get(configuration.slice(FLOWCHART_PREFIX.length)) ?? null : null;
+}
+const GENERIC_SHAPES = [
+  ["ellipse", "ellipse"],
+  ["circle", "ellipse"],
+  ["oval", "ellipse"],
+  ["diamond", "diamond"],
+  ["decision", "diamond"],
+  ["hexagon", "hexagon"],
+  ["octagon", "octagon"],
+  ["triangle", "triangle"],
+  ["rect", "rectangle"],
+  ["process", "rectangle"],
+  ["box", "rectangle"]
+];
+const YED_POSITIONS = /* @__PURE__ */ new Map([
+  ["c", "center"],
+  ["t", "top"],
+  ["b", "bottom"],
+  ["l", "left"],
+  ["r", "right"],
+  ["tl", "top-left"],
+  ["tr", "top-right"],
+  ["bl", "bottom-left"],
+  ["br", "bottom-right"],
+  ["n", "top"],
+  ["s", "bottom"],
+  ["e", "right"],
+  ["w", "left"],
+  ["nw", "top-left"],
+  ["ne", "top-right"],
+  ["sw", "bottom-left"],
+  ["se", "bottom-right"]
+]);
+const FONT_STYLES = /* @__PURE__ */ new Map([
+  ["plain", ["normal", false]],
+  ["bold", ["bold", false]],
+  ["italic", ["normal", true]],
+  ["bolditalic", ["bold", true]]
+]);
+function readColor(raw, property, opacity, put, at) {
+  const c = canonColor(raw, "yed", at(property));
+  if (c === null) {
+    return;
+  }
+  put(property, c.color);
+  const alpha = colorOpacity(c, null, at(property), opacity !== null);
+  if (opacity !== null) {
+    put(opacity, alpha);
+  }
+}
+function readLabels(labels, node, put, at) {
+  let label = void 0;
+  let text = "";
+  let extra = 0;
+  for (const l of labels) {
+    const t = treeText(l)?.trim() ?? "";
+    if (t.length === 0 || treeAttr(l, "visible") === "false" || treeAttr(l, "hasText") === "false") {
+      continue;
+    }
+    if (label === void 0) {
+      label = l;
+      text = t;
+    } else {
+      extra++;
+    }
+  }
+  if (label === void 0) {
+    return;
+  }
+  if (extra > 0) {
+    noteAt(at("label"), STYLE_ISSUE.EXTRA_LABELS, `${String(extra + 1)} labels`);
+  }
+  put("label", canonText(text, at("label")));
+  readLabelLook(label, node, put, at);
+}
+function readLabelLook(label, node, put, at) {
+  readColor(treeAttr(label, "textColor"), "labelColor", null, put, at);
+  put("labelSize", canonNumber(treeAttr(label, "fontSize"), at("labelSize")));
+  put("labelFont", canonText(treeAttr(label, "fontFamily"), at("labelFont")));
+  const style = treeAttr(label, "fontStyle");
+  if (style !== void 0) {
+    const known = FONT_STYLES.get(style.trim().toLowerCase());
+    if (known === void 0) {
+      noteAt(at("labelWeight"), STYLE_ISSUE.UNKNOWN_VALUE, style.slice(0, MAX_STYLE_VALUE_LENGTH));
+    } else {
+      put("labelWeight", known[0]);
+      put("labelItalic", known[1]);
+    }
+  }
+  const position = node ? treeAttr(label, "modelPosition") : void 0;
+  if (position !== void 0) {
+    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);
+  }
+}
+function realizerShape(real, at) {
+  const shape = treeChild(real.r, "Shape");
+  if (shape !== void 0) {
+    return canonEnum("shape", treeAttr(shape, "type"), "yed", at("shape"));
+  }
+  if (real.type === "ShapeNode" || real.type === "GroupNode" || real.type === "GenericGroupNode") {
+    return null;
+  }
+  if (real.type === "GenericNode") {
+    const conf = treeAttr(real.r, "configuration") ?? "";
+    const flowchart = flowchartShape(conf);
+    if (flowchart !== null) {
+      return flowchart;
+    }
+    const lower = conf.slice(0, MAX_STYLE_VALUE_LENGTH).toLowerCase();
+    for (const [word, value] of GENERIC_SHAPES) {
+      if (lower.includes(word)) {
+        return value;
+      }
+    }
+    if (lower.length === 0) {
+      return null;
+    }
+    noteAt(at("shape"), STYLE_ISSUE.UNKNOWN_VALUE, lower);
+    return `other:${lower}`;
+  }
+  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 border = treeChild(r, "BorderStyle");
+  if (border !== void 0) {
+    if (treeAttr(border, "hasColor") === "false") {
+      put("borderWidth", 0);
+    } else {
+      readColor(treeAttr(border, "color"), "borderColor", null, put, at);
+      put("borderWidth", canonNumber(treeAttr(border, "width"), at("borderWidth")));
+    }
+    put("borderStyle", canonEnum("borderStyle", treeAttr(border, "type"), "yed", at("borderStyle")));
+  }
+  const geometry = treeChild(r, "Geometry");
+  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);
+}
+function readEdge(real, put, at) {
+  const { r } = real;
+  const line = treeChild(r, "LineStyle");
+  if (line !== void 0) {
+    readColor(treeAttr(line, "color"), "color", "opacity", put, at);
+    put("width", canonNumber(treeAttr(line, "width"), at("width")));
+    put("lineStyle", canonEnum("lineStyle", treeAttr(line, "type"), "yed", at("lineStyle")));
+  }
+  const arrows = treeChild(r, "Arrows");
+  if (arrows !== void 0) {
+    put("sourceArrow", canonEnum("arrow", treeAttr(arrows, "source"), "yed", at("sourceArrow")));
+    put("targetArrow", canonEnum("arrow", treeAttr(arrows, "target"), "yed", at("targetArrow")));
+  }
+  put("curved", edgeCurved(real));
+  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") {
+    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) => [
+    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);
+}
+function valueColumns(n) {
+  const values = /* @__PURE__ */ Object.create(null);
+  return {
+    values,
+    put(i, property, value) {
+      if (value !== null) {
+        values[property] ??= new Array(n).fill(null);
+        values[property][i] = value;
+      }
+    }
+  };
+}
+function readYedStyles(snapshot, notes, budget) {
+  let found = false;
+  const centers = new Float64Array(2 * snapshot.nodeCount).fill(Number.NaN);
+  const read = (target) => {
+    const table = target === "node" ? snapshot.nodes : snapshot.edges;
+    const n = target === "node" ? snapshot.nodeCount : snapshot.edgeCount;
+    const names = target === "node" ? NODE_REALIZERS : EDGE_REALIZERS;
+    const columns = treeColumns(table);
+    const out = valueColumns(n);
+    if (columns.length === 0) {
+      return out.values;
+    }
+    for (let i = 0; i < n; i++) {
+      budget.spend(target, columns.length);
+      let real = null;
+      for (let c = 0; c < columns.length && real === null; c++) {
+        real = realizerOf(plainCell(table.value(columns[c], i)), names);
+      }
+      if (real === null) {
+        continue;
+      }
+      found = true;
+      const at = (property) => ({ notes, target, property, element: i, budget });
+      const put = (property, value) => {
+        out.put(i, property, value);
+      };
+      if (target === "node") {
+        readNode(real, put, at);
+        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;
+      } else {
+        readEdge(real, put, at);
+        put("bends", edgeBends(real, centers, snapshot.edgeSource(i), snapshot.edgeTarget(i)));
+      }
+    }
+    return out.values;
+  };
+  const node = read("node");
+  const edge = read("edge");
+  return found ? { node, edge } : null;
+}
+const GRAPHML_STYLE_CAPABILITIES = Object.freeze({
+  node: Object.freeze([
+    "fill",
+    "fillOpacity",
+    "borderColor",
+    "borderWidth",
+    "borderStyle",
+    "shape",
+    "width",
+    "height",
+    "label",
+    "labelColor",
+    "labelSize",
+    "labelFont",
+    "labelWeight",
+    "labelItalic",
+    "labelPosition"
+  ]),
+  edge: Object.freeze([
+    "color",
+    "opacity",
+    "width",
+    "lineStyle",
+    "sourceArrow",
+    "targetArrow",
+    "curved",
+    "bends",
+    "label",
+    "labelColor",
+    "labelSize",
+    "labelFont",
+    "labelWeight",
+    "labelItalic"
+  ]),
+  block: "attributes"
+});
+const YED_SHAPES = /* @__PURE__ */ new Map([
+  ["ellipse", "ellipse"],
+  ["rectangle", "rectangle"],
+  ["round-rectangle", "roundrectangle"],
+  ["triangle", "triangle"],
+  ["diamond", "diamond"],
+  ["hexagon", "hexagon"],
+  ["octagon", "octagon"],
+  ["parallelogram", "parallelogram"],
+  ["trapezoid", "trapezoid"],
+  ["star", "star5"]
+]);
+const YED_LINES = /* @__PURE__ */ new Map([
+  ["solid", "line"],
+  ["dashed", "dashed"],
+  ["dotted", "dotted"],
+  ["dash-dot", "dashed_dotted"]
+]);
+const YED_ARROWS = /* @__PURE__ */ new Map([
+  ["none", "none"],
+  ["triangle", "standard"],
+  ["triangle-open", "white_delta"],
+  ["vee", "concave"],
+  ["tee", "t_shape"],
+  ["diamond", "diamond"],
+  ["diamond-open", "white_diamond"],
+  ["circle", "circle"],
+  ["circle-open", "white_circle"],
+  ["square", "skewed_dash"],
+  ["crow", "crows_foot_many"]
+]);
+const YED_MODEL_POSITIONS = /* @__PURE__ */ new Map([
+  ["center", "c"],
+  ["top", "t"],
+  ["bottom", "b"],
+  ["left", "l"],
+  ["right", "r"],
+  ["top-left", "tl"],
+  ["top-right", "tr"],
+  ["bottom-left", "bl"],
+  ["bottom-right", "br"]
+]);
+function yedValue(table, value, nearest) {
+  const exact = table.get(value);
+  if (exact !== void 0) {
+    return { value: exact, exact: true };
+  }
+  return value.startsWith("other:") ? { value: value.slice(6), exact: true } : { value: nearest, exact: false };
+}
+function yedColor(color, opacity) {
+  const hex = color.toUpperCase();
+  if (typeof opacity !== "number" || opacity >= 1) {
+    return hex;
+  }
+  return hex + Math.round(Math.max(0, opacity) * 255).toString(16).toUpperCase().padStart(2, "0");
+}
+function yedSpelled(table, value, nearest, property, approximate) {
+  const w = yedValue(table, value, nearest);
+  if (!w.exact) {
+    approximate(property, value);
+  }
+  return w.value;
+}
+function labelTree(get, node, approximate) {
+  const text = get("label");
+  if (typeof text !== "string" || text.trim().length === 0) {
+    return null;
+  }
+  const label = {};
+  const font = get("labelFont");
+  if (typeof font === "string") {
+    label["@_fontFamily"] = font;
+  }
+  const size = get("labelSize");
+  if (typeof size === "number") {
+    label["@_fontSize"] = String(size);
+  }
+  const weight = get("labelWeight");
+  const italic = get("labelItalic");
+  if (weight !== null || italic !== null) {
+    const style = (weight === "bold" ? "bold" : "") + (italic === true ? "italic" : "");
+    label["@_fontStyle"] = style.length === 0 ? "plain" : style;
+  }
+  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) {
+      approximate("labelPosition", position);
+    }
+    label["@_modelName"] = "internal";
+    label["@_modelPosition"] = written ?? "c";
+  }
+  label["#text"] = text;
+  return label;
+}
+function shapeNodeTree(get, at, approximate) {
+  const node = {};
+  node["y:Geometry"] = geometryTree(get, at);
+  const fill = get("fill");
+  const fillOpacity = get("fillOpacity");
+  if (typeof fill === "string") {
+    node["y:Fill"] = { "@_color": yedColor(fill, fillOpacity), "@_transparent": "false" };
+  } else if (fillOpacity === 0) {
+    node["y:Fill"] = { "@_hasColor": "false", "@_transparent": "false" };
+  }
+  const border = lineTree(get, ["borderColor", "borderWidth", "borderStyle"], approximate);
+  if (border !== null) {
+    node["y:BorderStyle"] = border;
+  }
+  const label = labelTree(get, true, approximate);
+  if (label !== null) {
+    node["y:NodeLabel"] = label;
+  }
+  const shape = get("shape");
+  if (typeof shape === "string") {
+    node["y:Shape"] = {
+      "@_type": yedSpelled(YED_SHAPES, shape, shape === "vee" ? "triangle" : "rectangle", "shape", approximate)
+    };
+  }
+  return { "y:ShapeNode": node };
+}
+function geometryTree(get, at) {
+  const geometry = {};
+  const height = get("height");
+  const width = get("width");
+  if (typeof height === "number") {
+    geometry["@_height"] = String(height);
+  }
+  if (typeof width === "number") {
+    geometry["@_width"] = String(width);
+  }
+  if (at !== null) {
+    geometry["@_x"] = at[0];
+    geometry["@_y"] = at[1];
+  }
+  return geometry;
+}
+function lineTree(get, properties, approximate, opacity) {
+  const [colorKey, widthKey, styleKey] = properties;
+  const color = get(colorKey);
+  const width = get(widthKey);
+  const style = get(styleKey);
+  if (color === null && width === null && style === null) {
+    return null;
+  }
+  const line = {};
+  if (typeof color === "string") {
+    line["@_color"] = opacity === void 0 ? color.toUpperCase() : yedColor(color, opacity);
+  }
+  if (typeof style === "string") {
+    const nearest = styleKey === "lineStyle" && style === "long-dash" ? "dashed" : "line";
+    line["@_type"] = yedSpelled(YED_LINES, style, nearest, styleKey, approximate);
+  }
+  if (typeof width === "number") {
+    line["@_width"] = String(width);
+  }
+  return line;
+}
+function polyLineEdgeTree(get, path, approximate) {
+  const edge = {};
+  if (path !== void 0) {
+    edge["y:Path"] = path;
+  }
+  const line = lineTree(get, ["color", "width", "lineStyle"], approximate, get("opacity"));
+  if (line !== null) {
+    edge["y:LineStyle"] = line;
+  }
+  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";
+    edge["y:Arrows"] = { "@_source": arrow("sourceArrow", source), "@_target": arrow("targetArrow", target) };
+  }
+  const label = labelTree(get, false, approximate);
+  if (label !== null) {
+    edge["y:EdgeLabel"] = label;
+  }
+  const curved = get("curved");
+  if (typeof curved === "boolean") {
+    edge["y:BendStyle"] = { "@_smoothed": String(curved) };
+  }
+  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);
+      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;
+        }
+      }
+    }
+  }
+}
+function writtenAndReadBack(target, want, notes) {
+  const ignore = () => void 0;
+  const tree = target === "node" ? shapeNodeTree(want, null, ignore) : polyLineEdgeTree(want, void 0, ignore);
+  const real = realizerOf(tree, target === "node" ? NODE_REALIZERS : EDGE_REALIZERS);
+  if (real === null) {
+    return null;
+  }
+  const back = /* @__PURE__ */ new Map();
+  const at = (property) => ({ notes, target, property });
+  const put = (property, value) => {
+    if (value !== null) {
+      back.set(property, value);
+    }
+  };
+  if (target === "node") {
+    readNode(real, put, at);
+  } else {
+    readEdge(real, put, at);
+  }
+  return back;
+}
+const GRAPHICS_TYPES = { node: "nodegraphics", edge: "edgegraphics" };
+function keptPosition(table, columns, i) {
+  for (const name of columns) {
+    const tree = plainCell(table.value(name, i));
+    const real = realizerOf(tree, NODE_REALIZERS);
+    const geometry = real === null ? treeChild(tree, "RectD") : treeChild(real.r, "Geometry");
+    const x = treeAttr(geometry, real === null ? "X" : "x");
+    const y = treeAttr(geometry, real === null ? "Y" : "y");
+    if (x !== void 0 && y !== void 0) {
+      return [x, y];
+    }
+  }
+  return null;
+}
+function columnPosition(snapshot, i, get) {
+  const column = snapshot.nodes.byRole("position");
+  if (column === null || column.meta.components < 2 || !column.isSet(i)) {
+    return null;
+  }
+  const v = column.value(i);
+  const width = get("width");
+  const height = get("height");
+  const size = [typeof width === "number" ? width : 0, typeof height === "number" ? height : 0];
+  const p = [v[0], v[1], 0];
+  toNeutral(p, column.meta.extra ?? {}, size, false);
+  const [x, y] = toFilePositions(Float64Array.from(p), YED_SPELLING, {
+    width: Float64Array.of(size[0]),
+    height: Float64Array.of(size[1])
+  });
+  return Number.isFinite(x) && Number.isFinite(y) ? [String(x), String(y)] : null;
+}
+const YED_SPELLING = { yAxis: "down", anchor: "top-left" };
+function keptPath(table, columns, e) {
+  for (const name of columns) {
+    const real = realizerOf(plainCell(table.value(name, e)), EDGE_REALIZERS);
+    const path = real === null ? void 0 : treeChild(real.r, "Path");
+    if (path !== void 0) {
+      return path;
+    }
+  }
+  return void 0;
+}
+function pathWithBends(kept, bends, ends) {
+  const points = typeof bends === "string" ? bendsToPoints(ends[0], ends[1], bends) : null;
+  if (points === 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) }));
+  return path;
+}
+function freeName(table, base) {
+  let name = base;
+  let k = 2;
+  while (table.has(name)) {
+    name = `${base}#${String(k)}`;
+    k++;
+  }
+  return name;
+}
+function graphmlStyledExport(snapshot, input) {
+  if (input === void 0) {
+    return null;
+  }
+  const approximated = new StyleApproximations();
+  const approximateFor = (target) => (property, value) => {
+    approximated.add(target, property, value);
+  };
+  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 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 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];
+  });
+  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);
+    edgeTrees.push(polyLineEdgeTree(get, path, approximateFor("edge")));
+  }
+  const out = snapshot.withColumns();
+  for (const [table, trees, target] of [
+    [out.nodes, nodeTrees, "node"],
+    [out.edges, edgeTrees, "edge"]
+  ]) {
+    for (const name2 of yfilesColumns(table)) {
+      table.remove(name2);
+    }
+    const name = freeName(table, GRAPHICS_TYPES[target]);
+    table.set(name, trees, {
+      dtype: "json",
+      nullable: true,
+      origin: { format: "graphml", id: null, title: null, type: GRAPHICS_TYPES[target], namespace: "yfiles" }
+    });
+  }
+  const yfiles3 = [...out.graph].filter(
+    (col) => col.meta.origin?.namespace === "yfiles" && (col.meta.origin.type ?? "").includes("://")
+  );
+  for (const col of yfiles3) {
+    out.graph.remove(col.meta.name);
+  }
+  return { snapshot: out, notes: approximated.notes("yEd") };
+}
+export {
+  FONT_STYLES as F,
+  GRAPHML_STYLE_CAPABILITIES as G,
+  YED_SHAPES as Y,
+  treeAttr as a,
+  treeChild as b,
+  treeText as c,
+  yedValue as d,
+  exactFromBlock as e,
+  yedColor as f,
+  graphmlStyledExport as g,
+  yedSpelled as h,
+  isTree as i,
+  bendsToPoints as j,
+  YED_LINES as k,
+  localOf as l,
+  canonBends as m,
+  flowchartShape as n,
+  YED_ARROWS as o,
+  readYedStyles as r,
+  treeChildren as t,
+  valueColumns as v,
+  yfilesColumns as y
+};
+//# sourceMappingURL=styles-yed-DAfcIkf7.js.map